[RFC PATCH 0/5] XAudio PE conversion.

[Rémi Bernon]

On 6/25/21 2:38 PM, Jacek Caban wrote:
> On 6/23/21 8:38 PM, Alexandre Julliard wrote:
>> And honestly, building our dependencies as PE and linking them
>> statically would make things so much easier for everybody, that there
>> would need to be strong practical reasons to go out of our way to start
>> relying on distro packages for this. A general dislike of the approach
>> is not good enough IMHO.
> 
> 
> I agree that it's a good way to move forward.
> 
> To implement it, we will need to build dependencies with winegcc (rather 
> than plain mingw). I did experiment with it last year, you may see it here:
> 
> https://github.com/cjacek/wine-addons
> 
> While the build system itself is just a rough draft and needs 
> rethinking, it shows how to build static libs with winegcc (it links 
> them into standalone PE files, but they should be ready to statically 
> link to Wine modules as well).
> 
> We will probably also need such static libs to be more portable by 
> getting rid of libgcc dependency, but that's a latter step.
> 
> Jacek
> 

IMHO this is pretty inconvenient too.

Having to build with winegcc means that building full featured Wine 
would have to be done in three steps in worst case, where we need to 
build winegcc first (and Wine import libs and headers I guess?), then 
these dependencies, passing them wherever that was built, then Wine 
again for real, passing it wherever these dependencies have been built.

Developing on both sides is going to be even more inconvenient than the 
canonical Linux way where we have to build the dependencies with MinGW 
first, install them locally somewhere, and point Wine where it can find 
the headers and import libs.

Of course if the dependencies never change, it doesn't matter too much, 
and for these I would even be more in favor of Zeb's proposal. But for 
the ones which are likely to change, and which we will work on often, 
like FAudio, I think this should be somehow directly integrated in Wine 
build process in a straightforward way.

This means either import their source, or make Wine build able to build 
them from an external source directory. It's actually pretty much the 
same as this here, but better integrated (and I don't even think we have 
to use upstream build systems to build the sources we need).

Cheers,
-- 
Rémi Bernon <rbernon at codeweavers.com>