Join GitHub today
GitHub is home to over 28 million developers working together to host and review code, manage projects, and build software together.Sign up
C C++ CMake Objective-C Objective-C++ Python Other
Fetching latest commit…
Cannot retrieve the latest commit at this time.
|Failed to load latest commit information.|
What is OBS? This project is a rewrite of what was formerly known as "Open Broadcaster Software", software originally designed for recording and streaming live video content, efficiently. Bug Tracker: https://obsproject.com/mantis/ We are no longer using GitHub issues! Please use Mantis, and only report bugs and major issues. Do NOT use mantis to ask questions or request features, please keep that to the forums. Forum accounts are now linked to Mantis Bug Tracker. To use the bug tracker, simply log in to the forums and then go to the bug tracker link above. What's the goal of rewriting OBS? - Make it multiplatform. Use multiplatform libraries/functions/classes where possible to allow this. Multi-platform support was one of the primary reasons for the rewrite. This also means using a UI toolkit will be necessary for user interface. It also means allowing the use of OpenGL as well as Direct3D. - Separate the application from the core, allowing custom application of the core if desired, and easier extending of the user interface. - Simplify complex systems to not only make it easier to use, but easier to maintain. - Write a better core API, and design the entire system to be modular. - Now that we have much more experience, improve the overall design of all the subsystems/API, and minimize/eliminate design flaws. Make it so we can do all the things we've had trouble with before, such as custom outputs, multiple outputs at once, better handling of inputs, custom services. - Make a better/cleaner code base, use better coding standards, use standard libraries where possible (not just STL and C standard library, but also things like ffmpeg as well), and improve maintainability of the project as a whole. - Implement a new API-independent shader/effect system allowing better and easier shaders usage and customization without having to duplicate shader code. - Better device support. Again, I didn't know what I was getting into when I originally started writing code for devices. It evolved into a totally convoluted mess. I would have improved the existing device plugin code, but it was just all so fundamentally bad and flawed that it would have been detrimental to progression to continue working on it rather than rewrite it. What was wrong with the original OBS? The original OBS was rewritten not because it was bad, at least in terms of optimization. Optimization and graphics are things I love. However, there were some serious problems with the code and design that were deep and fundamental, which prevented myself and other developers from being able to improve/extend the application or add new features very easily. First, the design flaws: - The original OBS was completely and hopelessly hard-coded for windows, and only windows. It was just totally impossible to use it on other systems. - All the sub-systems were written before I really knew what I was getting into. When I started the project, I didn't really fully comprehend the scope of what I would need or how to properly design the project. My design and plans for the application were just to write something that would "stream games and a webcam, with things like overlays and such." This turned out fine for most casual gamers and streamers (and very successful), but left anyone wanting to do anything more advanced left massively wanting. - Subsystems and core functionalities intermingled in such a way that it was a nightmare to get proper custom functionality out of it. Things like QSV had to be meshed in with the main encoding loop, and it just made things a nightmare to deal with. Custom outputs were nigh impossible. - The API was poorly designed because most of it came after I originally wrote the application, it was more of an afterthought, and plugin API would routinely break for plugin developers due to changing C++ interfaces (one of the reasons the core is now C). - API was intermeshed with the main executable. The OBSApi DLL was nothing more than basically this mutant growth upon OBS.exe that allowed plugin developers to barely write plugins, but all the important API code was actually stored in the executable. Navigation was a total mess. - The graphics subsystem, while not bad, was incomplete, and though far easier to use than bare D3D, wasn't ideal, and was hard-coded for D3D specifically. - The devices and audio code was poor, I had no idea what I was getting into when I started writing them in. I did not realize beforehand all the device-specific quirks that each device/system could have. Some devices had bad timing and quirks that I never aniticipated while writing them. I struggled with devices, and my original design for the audio subsystem for example morphed over and over into an abomination that, though works, is basically this giant duct-taped zombie monster. - Shaders were difficult to customize because they had to be duplicated if you wanted slightly different functionality that required more than just changing shader constants. - Orientation of sources was fixed, and required special code for each source to do any custom modification of rotation/position/scale/etc. This is one of those fundamental flaws that I look back on and regret, as it was a stupid idea from the beginning. I originally thought I could get more accurate source position/sizes, but it just turned out to be totally bad. Should have been matrices from the beginning just like with a regular 3D engine. Second, the coding flaws: - The coding style was inconsistent. - C++98, C-Style C++, there was no exception usage, no STL. C++ used poorly. - Not Invented Here Syndrome everywhere. Custom string functions/classes, custom templates, custom everything everywhere. To be fair, it was all hand-me-down code from the early 2000s that I had become used to, but that was no excuse -- C-standard libraries and the STL should have been used from the beginning over anything else. That doesn't mean to say that using custom stuff is always bad, but doing it to the extent I did definitely was. Made it horrible to maintain as well, required extra knowledge for plugin developers and anyone messing with the code. - Giant monolithic classes everywhere, the main OBS class was paricularly bad in this regard. This meant navigation was a nightmare, and no one really knew where to go or where to add/change things. - Giant monolithic functions everywhere. This was particularly bad because it meant that functions became harder to debug and harder to keep track of what was going on in any particular function at any given time. These large functions, though not inefficient, were delicate and easily breakable. (See OBS::MainCaptureLoop for a nightmarish example, or the listbox subclass window procedure in WindowStuff.cpp) - Very large file sizes with everything clumped up into single files (for another particularly nightmarish example, see WindowStuff.cpp) - Bad formatting. Code could go beyond 200 columns in some cases, making it very unpleasant to read with many editors. Spaces instead of tabs, K&R mixed with allman (which was admittedly my fault). New (actual) coding guidelines - For the C code (especially in the core), guidelines are pretty strict K&R, kernel style. See the linux kernel "CodingStyle" document for more information. That particular coding style guideline is for more than just style, it actually helps produce a better overall code base. - For C++ code, I still use CamelCase instead of all_lowercase just because I prefer it that way, it feels right with C++ for some reason. It also helps make it distinguishable from C code. - I've started using 8-column tabs for almost everything -- I really personally like it over 4-column tabs. I feel that 8-column tabs are very helpful in preventing large amounts of indentation. A self-imposed limitation, if you will. I also use actual tabs now, instead of spaces. Also, I feel that the K&R style looks much better/cleaner when viewed with 8-column tabs. - Preferred maximum columns: 80. I've also been doing this because in combination with 8-column tabs, it further prevents large/bad functions with high indentation. Another self-imposed limitation. Also, it makes for much cleaner viewing in certain editors that wrap (like vim).