ubuntuusers.de

Kompilieren

Dieser Artikel wurde für die folgenden Ubuntu-Versionen getestet:


Du möchtest den Artikel für eine weitere Ubuntu-Version testen? Mitarbeit im Wiki ist immer willkommen! Dazu sind die Hinweise zum Testen von Artikeln zu beachten.

Der Vorteil eines selbst kompiliertem Wine ist, dass es perfekt an den eigenen PC angepasst ist, Patches eingespielt und Kollisionen zwischen Wine und vorinstallierten Paketen vermieden werden können. Dieser Artikel erläutert zusätzlich die Installation und Deinstallation selbst kompilierter Wine-Pakete.

Varianten des selbst kompilierten Wine

Es gibt eine Vielzahl an Optionen mit denen Wine kompiliert werden kann. So kann sowohl eine pure 32 als auch 64 bit Version kompiliert werden oder auch wine mit WOW64, dieses ist ein 64bit Wine, welches ein 32 bit Subsystem enthält und somit auch 32 bit Anwendungen ausführen kann. Alle diese Versionen können dann z.B. auch zusätzlich mit dem Staging Patchset versehen werden (wine-staging). Bevor man startet sollten sich Gedanken gemacht werden, was man davon braucht. So treibt ein wine mit WoW64 Unterstützung die Kompilierzeit stark nach oben, obwohl es vielleicht bei puren 32 oder 64 bit Anwendungen nicht benötigt wird. Das Staging-Patchset kann zudem sowohl Probleme bei Patches machen, oder auch als Abhängigkeit für diese benötigt werden, hier nach lesen was für den Patch benötigt wird. Für WoW64 Unterstützung muss sowohl ein 32 als auch 64 bit Wine kompiliert werden, hier wird zunächst Wine im 64 bit Container kompiliert und dann Anschließend im 32 bit, bis spezifische Schritte für WoW64 kommen.

Aufsetzen eines LXC Containers

Dieser Artikel behandelt die Kompilierung von Wine in einem LXC-Container, alternativ kann Wine natürlich auch auf dem eigenem Computer oder mit einer anderen Virtualisierung, wie einer VM, bzw. mit chroot kompiliert werden.

Container installieren

Der Container kann mit

  • lxc

  • lxc-templates

Befehl zum Installieren der Pakete:

sudo apt-get install lxc lxc-templates 

Oder mit apturl installieren, Link: apt://lxc,lxc-templates

installiert werden.

Aufsetzen des Containers

Es muss für die Kompilierung von Wine in jeweils der 32-bit-, als auch in der 64-bit-Version ein eigener Container erstellt werden:

sudo lxc-create -t download -n ubuntu_wine64 -- --bindhome $LOGNAME --release bionic -a amd64 

für den 64-bit-Container und für 32bit Container:

sudo lxc-create -t download -n ubuntu_wine32 -- --bindhome $LOGNAME --release bionic -a i386 

Im nachfolgenden werden diese Container mit dem Namen "ubuntu_wine32/64" referenziert, gemeint ist damit, dass der Befehl in beiden Containern, bzw. in dem dessen Wine Version man kompilieren möchte, ausgeführt wird. Den Container folgendermaßen starten:

sudo lxc-start -n ubuntu_wine32/64
sudo lxc-attach -n ubuntu_wine32/64 

und anschließend muss man sich noch im Container mit

login 

und den ganz normalen Benutzerdaten anmelden, damit Wine nicht als root Kompiliert wird.

Abhängigkeiten

Alle erforderlichen Pakete zum Kompilieren, Installieren und Benutzen von Wine müssen manuell installiert werden, auf die die Identifizierung dieser Pakete wird später eingegangen. Am Anfang benötigt man build-essential sowie andere feste Abhängigkeiten, diese können mit

  • git

  • build-essential

  • flex

  • bison

  • xserver-xorg-dev

  • libxft-dev

Befehl zum Installieren der Pakete:

sudo apt-get install git build-essential flex bison xserver-xorg-dev libxft-dev 

Oder mit apturl installieren, Link: apt://git,build-essential,flex,bison,xserver-xorg-dev,libxft-dev

installiert werden.

Kompilieren

Anschließend wird der Wine Quellcode nur heruntergeladen, ohne ihn zu kompilieren, damit man zuvor noch Einstellungen vornehmen kann:

git clone git://source.winehq.org/git/wine.git ~/wine-dirs/wine-source 

Wer mehrere Wine Versionen kompilieren und benutzen möchte, sollte dafür sorgen, dass diese nicht alle im Ordner wine-source landen, da bereits heruntergeladene Quellcodes damit überschrieben werden. Die nachfolgenden Befehle müssen dann auch auf den selbst gewählten Pfad angepasst werden.

Anschließend erstellt man ein neues Verzeichnis zum kompilieren und wechselt in dieses, nachfolgend wird der Ordner im dem Wine kompiliert wird als wine32/64 referenziert, gemeint ist damit, dass die Endung für die Architektur auf der kompiliert wird, angepasst werden muss:

mkdir ~/wine-dirs/wine32/64
cd ~/wine-dirs/wine32/64 

Wine konfiguieren

Anschließend kann man Wine konfigurieren, dieser Schritt unterscheidet sich je nachdem, ob man ein 32- oder ein 64-bit-System benutzt. Dessen ungeachtet können natürlich noch andere Optionen hinzugefügt werden.

Im 32-bit-Container für ein 32-bit-Wine:

./../wine-source/configure 

Im 64-bit-Container für ein 64-bit-Wine:

./../wine-source/configure --enable-win64 

Nun können noch Patches angewendet werden. Diese müssen bei WoW64 nur einmal Angewendet werden, da sowohl die 32 als auch 64 bit Architektur aus dem selben Quellcode gebaut werden. Die Patches müssen zu dem auf ../wine-source Angewendet werden.

Anwenden des Staging-Patchsets

Zunächst wine-staging herunterladen:

git clone https://github.com/wine-staging/wine-staging 

Vor dem Anwenden muss noch der Wine Quellcode auf die letzte unterstütze Staging Version herabgesetzt werden:

cd wine-staging
git clean -fxd
git reset --hard origin/master
git pull --force
cd ../../wine-source
git clean -fxd
git pull --force
git reset --hard "$(../wine-staging/patches/patchinstall.sh --upstream-commit)"
cd ../wine32/64 

Und dann Anwenden mit

wine-staging/patches/patchinstall.sh --all --backend=git-am --force-autoconf DESTDIR=../wine-source 

Installieren von Abhängigkeiten

Weitergehend wird beschrieben, wie sich Abhängigkeiten manuell herausfinden lassen. Wer eine vollständige liste aller Abhängigkeiten wünscht kann diese inklusive Verwendeter Ubuntu und Wine Version 🇬🇧hier nachlesen.

Nachdem ./configure Befehl, sollten noch jede menge fehlende Abhängigkeiten am Ende aufgelistet werden. Wer diese nicht benötigt kann mit

./configure --without-name 

eine Abhängigkeit auslassen, eine volle Auflistung von weglassbaren Abhängigkeiten erhält man mit

./configure --help 

Hierbei ist es empfohlen mit

./configure --without-hal 

libhal auszulassen, da sich dieses Paket nicht in den offiziellen Paketquellen befindet. Wer es unbedingt benötigt kann es durch eine Fremdquelle hinzufügen. Außerdem sollte oss ausgelassen werden, solange man dieses nicht benutzt.

In der Regel lassen sich die Abhängigkeiten recht einfach installieren, hierzu reicht oft einfach der Name des Paketes an den ein -dev angehängt ist, zum Beispiel für die Abhängigkeit libxrandr:

  • libxrandr-dev

Befehl zum Installieren der Pakete:

sudo apt-get install libxrandr-dev 

Oder mit apturl installieren, Link: apt://libxrandr-dev

Hierzu gibt es Ausnahmen, zum Beispiel heißt das Paket für libgnutls: libnutls28-dev und nicht libgnutls-dev. Für die Identifizierung der Namen kann die Seite packages.ubuntu.com 🇩🇪 zur Hilfe genommen werden. Wer hier nach einem Dateinamen sucht, wie libgnutls 🇩🇪 erhält hier die Namen von Paketen, welche libgnutls enthalten.

Abhängigkeiten die sich nicht in den Paketquellen befinden

Zur Zeit gibt es zwei Abhängigkeiten, die sich nicht in den Bionic Paketquellen befinden. Nämlich vkd3d und libfaudio diese können entweder aus einem PPA bezogen -oder selbst gebaut werden.

vkd3d

Wer diese für DirectX12 Support benötigt, muss sie selber kompilieren.

Zunächst wird der Quellcode heruntergeladen:

git clone git://source.winehq.org/git/vkd3d.git/ 

Als nächstes muss noch widl aus dem wine Quellcode als Abhängigkeit für vkd3d gebaut werden:

make tools/widl 

Als weitere Abhängigkeiten benötigt vkd3d SPIV-headers und Vulkan-headers diese können folgendermaßen kompiliert werden:

  • cmake

Befehl zum Installieren der Pakete:

sudo apt-get install cmake 

Oder mit apturl installieren, Link: apt://cmake

SPIRV-headers:

git clone https://github.com/KhronosGroup/SPIRV-Headers.git
cd SPIRV-Headers/
mkdir build
cd build
cmake ..
sudo cmake --build . --target install
cd ../.. 

Vulkan-headers:

git clone https://github.com/KhronosGroup/Vulkan-Headers.git
cd Vulkan-Headers/
cd SPIRV-Headers/
mkdir build
cd build
cmake ..
sudo cmake --build . --target install
cd ../.. 

Nun kann vkd3d kompiliert und installiert werden:

cd vkd3d
./autogen.sh
./configure WIDL="$HOME/wine-dirs/wine32/64/tools/widl/widl"
make
sudo make install
cd .. 

Im 32 bit Container müssen noch die Argumente --build=i686-pc-linux-gnu "CPPFLAGS=-m32" "LDFLAGS=-m32" an den ./configure Befehl angehängt werden.

libfaudio

Für libfaudio wird folendes PPA hinzugefügt:

Adresszeile zum Hinzufügen des PPAs:

  • ppa:cybermax-dexter/sdl2-backport

Hinweis!

Zusätzliche Fremdquellen können das System gefährden.


Ein PPA unterstützt nicht zwangsläufig alle Ubuntu-Versionen. Weitere Informationen sind der Wiki/Vorlagen/PPA/ppa.png PPA-Beschreibung des Eigentümers/Teams cybermax-dexter zu entnehmen.

Allerdings ist das hinzufügen von PPAs in LXC Containern etwas aufwendiger zur Installation werden die folgenden Befehle ausgeführt:

echo "deb http://ppa.launchpad.net/cybermax-dexter/sdl2-backport/ubuntu bionic main"  | sudo tee /etc/apt/sources.list.d/libfaudio.list
sudo gpg --ignore-time-conflict --no-options --no-default-keyring --secret-keyring /etc/apt/secring.gpg --trustdb-name /etc/apt/trustdb.gpg --keyring /etc/apt/trusted.gpg --keyserver keyserver.ubuntu.com --recv BBB8BD3BBE6AD3419048EDC50795A9A788A59C82
sudo apt updtate
sudo apt install libfaudio-dev 

Wine bauen

Nach dem Wine Konfiguriert und alle Abhängigkeiten eingerichtet wurden, kann es nun gebaut werden mit

make -jN 

wobei N der Anzahl der CPU-Kerne entspricht, die für den Kompiliervorgang verwendet werden.

Anschließend kann der LXC-Container verlassen werden mit

exit
exit 

Extra Schritte für WoW64

Nach dem Wine für beide Systeme kompiliert wurde, wird sich in den 32bit Container begeben. Hier wird ein neuer Ordner namens wine32-combo und erstellt sich in diesen begeben:

mkdir ~/wine-dirs/wine32-combo
cd ~/wine-dirs/wine32-combo 

Anschließend wird Wine noch ein letztes mal konfiguriert:

../wine-source/configure --with-wine64=../wine64 --with-wine-tools=../wine32 

Abschließend Wine dann noch ein drittes mal kompilieren:

make -jN 

Abschließend kann der Container verlassen werden.

Wine ausführen

Das gebaute wine kann nun gestartet werden, der LXC-Parameter --bindhome beim Aufsetzen des Containers sorgt dafür, dass sich Wine im normalen Benutzer Verzeichnis befindet.

Es kann mit dem im selben Verzeichnis enthaltenen wine-Skript benutzt werden, unabhängig davon, welche andere Wine Version bereits im System installiert ist.

Für die 64-bit-Version

$HOME/wine-dirs/wine-source64/wine 

Für 32-bit-Version:

$HOME/wine-dirs/wine-source32/wine 

Für Wow64

$HOME/wine-dirs/wine32-combo/wine 

Deinstallation

Wer das selbst kompilierte Wine wieder ersetzen will, muss einfach nur den Ordner wine-dirs/installierteVersion löschen. installierteVersion ist durch die installierte Version zu ersetzen.

Diese Revision wurde am 8. August 2020 14:06 von haveaproblem erstellt.
Die folgenden Schlagworte wurden dem Artikel zugewiesen: Emulation und Virtualisierung, Wine, Windows