[[Vorlage(Getestet, focal)]] 

{{{#!vorlage Wissen
[:Pakete installieren: Installation von Programmen]
[:Terminal: Ein Terminal öffnen]
[:mit Root-Rechten arbeiten:]
[:Paketinstallation_DEB: Ein einzelnes Paket installieren]
[:Packprogramme: Archive entpacken], (optional)
[:Programme_kompilieren: Pakete aus dem Quellcode erstellen], (optional)
}}}

[[Inhaltsverzeichnis()]]

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 [wikipedia:WOW64: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 [:Archiv/LXC: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

{{{#!vorlage Paketinstallation
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:

{{{#!vorlage Befehl
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:

{{{#!vorlage Befehl
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:

{{{#!vorlage Befehl
sudo lxc-start -n ubuntu_wine32/64
sudo lxc-attach -n ubuntu_wine32/64
}}}
und anschließend muss man sich noch im Container mit
{{{#!vorlage Befehl
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

{{{#!vorlage Paketinstallation
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:

{{{#!vorlage Befehl
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:

{{{#!vorlage Befehl
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:

{{{#!vorlage Befehl
./../wine-source/configure
}}}

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

{{{#!vorlage Befehl
./../wine-source/configure --enable-win64
}}}

Nun können noch [:patch: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:
{{{#!vorlage Befehl
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:
{{{#!vorlage Befehl
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
{{{#!vorlage Befehl
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 {en}[https://dl.winehq.org/wine-builds/ubuntu/dists/bionic/main/source/Sources hier] nachlesen. 

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

{{{#!vorlage Befehl
./configure --without-name
}}}

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

{{{#!vorlage Befehl
./configure --help
}}}

Hierbei ist es empfohlen mit

{{{#!vorlage Befehl
./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''':

{{{#!vorlage Paketinstallation
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 [https://packages.ubuntu.com packages.ubuntu.com] {de} zur Hilfe genommen werden. Wer hier nach einem Dateinamen sucht, wie [https://packages.ubuntu.com/search?mode=filename&suite=focal&section=all&arch=any&keywords=libgnutls&searchon=contents libgnutls] {de} 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:

{{{#!vorlage Befehl
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:

{{{#!vorlage Befehl
make tools/widl
}}}

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

{{{#!vorlage Paketinstallation
cmake
}}}

''SPIRV-headers'':
{{{#!vorlage Befehl
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'':
{{{#!vorlage Befehl
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:

{{{#!vorlage Befehl
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:
[[Vorlage(PPA, cybermax-dexter, sdl2-backport)]]

Allerdings ist das hinzufügen von PPAs in LXC Containern etwas aufwendiger zur Installation werden die folgenden Befehle ausgeführt:
{{{#!vorlage Befehl
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

{{{#!vorlage Befehl
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
{{{#!vorlage Befehl
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:
{{{#!vorlage Befehl
mkdir ~/wine-dirs/wine32-combo
cd ~/wine-dirs/wine32-combo
}}}
Anschließend wird Wine noch ein letztes mal konfiguriert:
{{{#!vorlage Befehl
../wine-source/configure --with-wine64=../wine64 --with-wine-tools=../wine32
}}}
Abschließend Wine dann noch ein drittes mal kompilieren:
{{{#!vorlage Befehl
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
{{{#!vorlage Befehl
$HOME/wine-dirs/wine-source64/wine
}}}

Für 32-bit-Version:

{{{#!vorlage Befehl
$HOME/wine-dirs/wine-source32/wine
}}}

Für Wow64
{{{#!vorlage Befehl
$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.

= Links =
 * [:Wine:] {Übersicht}
 * [https://wiki.winehq.org/Building_Wine] {en} - Ein 32-bit-Wine in einem 64-bit-System kompilieren

# tag: Emulation und Virtualisierung, Windows, Wine