Updated compiler.pri to make use of the new /Zo
option to improve our debugging capabilities on optimized
builds. This flag is officially supported since
Visual Studio 2013 Update 3.
This patch updates the compiler flags under the assumption
of us using VC12. This mostly consists of dropping flags
this compiler already set by default as well as removing
a conditional. This might even still build from this point
on VC10 support is considered to be dropped.
Since ConnectDialog::accept calls are refused if no item is selected,
and the server last connected to is selected in ConnectDialog::timeTick
(after initialisation), it doesn't make sense for the Connect button
to be enabled before a server is selected.
If the XDG_RUNTIME_DIR environment variable is present the overlay
pipe and RPC socket will be created at..
$XDG_RUNTIME_DIR/MumbleSocket
$XDG_RUNTIME_DIR/MumbleOverlayPipe
Since we plan to drop Qt 4 support for building the client
soon'ish add an explicit 'qt4-legacy-compat' flag that has
to be set to still build the client with qt 4. If the flag
is not set we error out of the build to ensure the maintainer
has to actively aknowledge using a legacy version. Even
when the flag is set we still show a warning as a reminder.
Before this commit, Mumble indiscriminately attenuates applications.
A simple example: it would attenuate applications that were set to output
to HDMI -- something that wasn't always desirable. My HDMI wouldn't need
to be attenuated because I am able to physically distinguish between sound
coming from either my HDMI or my laptop and "tune in" accordingly.
A more advanced use case is my PulseAudio streaming setup. I create two
additional sinks: "stream" and "stream_spkr." The "stream" sink is used
when I want to send audio from an application to my stream but not to
my speakers/headset (i.e., background music or something). In this case,
before this commit Mumble would attenuate my program playing the
background music. If I am running Mumble off-stream (which I often am),
this leads the background music volume fluctuating for seemingly no reason.
The second sink, "stream_spkr" routes both to "stream" and my
speakers/headset via two module-loopbacks. In this way, anything I attach
to stream_spkr can be heard both by my viewers and myself.
The option to include attenuation on loopback modules is for advanced
configurations. Loopback modules are used to route audio, usually between
a sink monitor and a sink. Sometimes it might be beneficial to attenuate a
loopback module that goes into Mumble's sink. Sometimes, however it's
inconvenient such as in the case where a user moves an application to
another sink that uses a loopback to Mumble's sink in order to specifically
have Mumble ignore attenuation on that application. But, if the loopback
that carries the non-Mumble sink's audio back to Mumble's sink is attenuated
then there would still be indirect attenuation of that application. In my
configuration, an example is the loopback from stream_spkr.monitor to the
physical speakers.
Only PulseAusio is supported in this patch, but this functionality could
potentially be extended to other audio systems.
Murmur now uses Mumble's appcompat.manifest so it
can query and report its host operating system
correctly on Windows 10. Previously it reported
as Windows 8 on that platform.
The connect dialog has the capability to pre-fill itself from
mumble:// style URLs in the users clipboard. If those are not
given a custom ?title= argument the name was defaulted to the
host name which caused them to be considered custom by the
edit dialog. This patch resolves this issue.
Fixing the connect dialog after the Qt 5 transition wasn't
done correctly. The QUrlQuery class for parsing the url was
instantiated before the url itself was extracted from the
mime data and hence was always empty. This probably slipped
by as the query data is only used for setting the name of
the server item from the '?title=' part of the url.
This patch improves the usability of the connect dialog by
moving the server label to the bottom of the dialog and making
it track the hostname. This way the user gets a sensible default
while also being able to manually edit it afterwards.
Once the user edits the label it is seen as custom and will no
longer track the server address until the label field is
manually cleared by the user.
The speex library has been split into a codec part
(speex) and a dsp part (speex-dsp). As we still need
the codec for compatibility with 3rd party clients
only sending speex but still want the updates that
went into the dsp and codec since then this patch
modifies our build to enable that. To achieve that
we combined the two libraries back together. Doing
it this way might brittle but is only a temporary
solution until we can actually drop the codec part.
This is only possible for now because x86 uses the D3DCompiler_43.dll
and x64 uses the D3DCompiler_47.dll.
If we need both to use the same version, we'll need a more complex
directory structure.
But let's tackle that then.
Setting Mumble's priority class higher than the games
is a bad behavior which can cause inconsistency for
input timing in games such as Team Fortress 2.
The g15helper tool links against a static library
provided by Logitech. It is only available for
32-bit x86.
Use our new toolchain mechanism to enable g15helper
to be enabled for x64 builds.
The Win32 ExitProcess() API takes an UINT, and we
used to pass negative values to it.
Obviously, those negative values can be represented
just fine in an unsigned integer, but for the sake
of following the API and to avoid future confusion
this commit changes the error constants used by
the overlay helper program to be non-negative.
The old parsing was error-prone and hard to read.
We introduce the GetCommandLineArgs() function that returns
he program's arguments as a vector of strings.
Using this function makes the code that processes the arguments
much simpler and easier to understand.
Many of our slots determine which variables to use depending
on the sender of the signal. However, they weren't very careful
about any possible invalid states.
This change makes sure we fail if we're in invalid state.
Normally, Mumble itself will terminate the helper processes.
But if Mumble crashes, or is manually killed by the user, it
will not be able to terminate the helper processes itself.
In order to fix this, we create a way for the helpers to know
when their parent process has terminated.
This is implemented by creating an inheritable process handle
in Mumble, and passing its value to the helpers.
The helpers then WaitForSingleObject() on the parent handle, and
exits with status code 0 if it the WaitForSingleObject() call
returns successfully.
This adds hidden config options for disabling arch-specific
overlay helpers.
This is useful for people that only want the overlay for a
specific architecture, and also for debugging and troubleshooting
arch-specific overlay problems.
We need this in case there's a bug in one of the overlay helpers.
Without this, we would restart a crashed helper immediately. If this
bug is triggered every time the helper is run, we'd get into an infinite
restart loop, potentially making the host computer unresponsive.
OverlayPrivateWin used to only listen for process
termination. Technically, this should work just fine.
This change makes OverlayPrivateWin listen for process
errors as well, by subscribing to the error() signal
of the QProcess of each of our helpers.
The idea is that this could provide us helpful error
messages when troubleshooting issues where overlay
helpers are exiting untimely.
When Qt terminates a QProcess via the terminate()
method, it sends a WM_CLOSE message.
However, the overlay helper did not know of WM_CLOSE,
so it would quietly ignore it.
This commit teaches the overlay helper to exit on
WM_CLOSE.
This change adds a function, canRun64BitPrograms() to OverlayWinPrivate.
If the program is built for x64, the function unconditionally
returns true.
If the program is built for x86, the function uses a call to the
runtime-resolved kernel32!IsWow64Process to determine whether or
not the system is x64 capable.
This functionality is needed to avoid spawning the x64 helper in
case the system cannot support it. Doing so without care, like we
did previously, could be fatal because Mumble immediately restarts
the helper process if it terminates. This would presumably make the
host computer unusable.
Vtable offsetes is almost all that we store in the shared memory,
and they vary by architecture.
So, don't share the memory between arches. Instead, crate
arch-specific shared memory regions.
This splits fx11 into an x86 variant and an x64 variant.
This creates effects11_x86.lib and effects11_x64.lib, instead
of the single effects11.lib we had previously.
The minhook build is also tweaked. However, since minhook
is only used on x86_64, it is only built for x86_64.
Consequently, the library is still called minhook.lib.
The overlay itself is split into mumble_ol.dll and mumble_ol.exe
for x86, and mumble_ol_x64.dll and mumble_ol_x64.exe for x86_64.
These CONFIG options allow a .pro file to select which toolchain
its target should be built with.
To force a target to always be built for x86 (in both x86 and
x86_64 build environments), set CONFIG+=force-x86-toolchain.
The same thing is possible with force-x86_64-toolchain.
