Comment puis-je créer la version GPL et LGPL de Xuggler Xuggler?

Question

Existe-t-il des étapes spécifiques que je peux suivre pour générer le code source Xuggle Xuggler à partir de Windows 32 bits, Windows 64 bits, Linux 32 bits et Linux 64 bits? J'ai essayé plusieurs fois sur plusieurs systèmes et je reçois beaucoup d'erreurs différentes.

Mise à jour

J'ai passé plusieurs jours à essayer d'obtenir Xuggle Xuggler pour compiler (et cross-compilation). J'ai réussi à compiler à la fois la version originale du code GPL et une version LGPL. J'ai pensé que je posterais une réponse à ma propre question sur Stack Overflow pour partager mes connaissances.

Mise à jour sur Raspberry Pi

J'a pu construire et exécuter Xuggler sur le Raspberry Pi suivant ces mêmes instructions de base ci-dessous. Je viens d'utiliser ma version LGPL du code que je maintiens sur Github, et j'ai fait des modifications pour le Pi. Je peux aussi utiliser le fichier JAR compilé et les binaires sur mon Radxa Rock (un autre périphérique ARM). Si vous êtes intéressé dans la construction de la Pi, vous pouvez utiliser ma branche pi:

https://github.com/e-d/xuggle-xuggler

Si vous êtes paresseux et que vous voulez juste les fichiers .jar précompilés pour Pi/ARM:

GPL Version (supports H.264)

LGPL Version (no H.264 support)

Answer 1

Here is a formatted version of my answer in a published Google Document.

Pour être complet (et dans le cas où le lien est mort d'un jour), voici le texte moins bien formaté:

bâtiment Xuggle Xuggler (GPL et LGPL Versions sous licence)

[Linux 32 -bit, Linux 64 bits, Windows 32 bits, Windows 64-bit]

Pour construire la bibliothèque Xuggler Xuggle, vous avez besoin de deux machines virtuelles Linux exécutant Ubuntu 11.10 (systèmes d'exploitation 32 bits et 64 bits) . Une version 32 bits du système d'exploitation est requise pour compiler Linux 32 bits, compiler les versions 32 bits Windows et compiler les binaires Windows 64 bits. Une version 64 bits du système d'exploitation est requise pour générer des binaires Linux 64 bits. En utilisant VirtualBox, j'ai créé les deux machines virtuelles discutées ci-dessus avec les images de disque ubuntu-11.10-server-i386.iso et ubuntu-11.10-server-amd64.iso. Ce sont des versions de serveur sans tête d'Ubuntu.Une fois l'installation du système d'exploitation, procédez comme suit pour construire Xuggler (vous êtes invités à essayer différentes versions de dépendance et ne pas utiliser l'utilisateur root, mais ce que je l'ai fait à succès construire):

Modification à l'utilisateur root:

sudo su 

il suffit d'utiliser le répertoire de la racine:

cd /root 

apt-get update utiliser référentiel spécifique:

apt-get install python-software-properties 
add-apt-repository ppa:ferramroberto/java 
apt-get update 

Installer Java:

apt-get install sun-java6-jdk sun-java6-plugin 

Vérifiez la machine virtuelle Java HotSpot Java 6 est le java par défaut:

java -version 

Si la version incorrecte de Java apparaît, configurer la valeur par défaut en exécutant:

update-alternatives --config java 

Installez gcc, g ++, make et tous les autres éléments de construction:

apt-get install build-essential 

Installer yasm:

apt-get install yasm 

Open SSL Installation:

apt-get install openssl 

Installer le paquet de configuration:

apt-get install pkg-config 

Installer Git:

apt-get install git 

Installer Ant:

apt-get install ant-optional 

Installer JUnit:

apt-get install junit 

Installer MingGW pour être en mesure de construire pour Windows (MinGW-w64 peut faire 32 et 64 bits de Windows):

apt-get install mingw-w64 

Téléchargez le code source Xuggle configuré par LGPL (la fourchette d'Ed du code de la fourche de Jeff Wallace du code xuggle original de la GPL) ou la version originale de la GPL:

LGPL: git clone https://github.com/e-d/xuggle-xuggler.git 
GPL: git clone https://github.com/xuggle/xuggle-xuggler.git 

Compilez et générez les fichiers JAR (avec les binaires à l'intérieur). Veillez à exécuter la version Linux 64 bits sur la version 64 bits d'Ubuntu. Notez également qu'entre les versions, vous devrez exécuter "ant clobber" pour supprimer tous les fichiers compilés de l'architecture précédente. Pour générer run:

(32/64-bit Linux): ant stage 
(64-bit Windows): ant -Dbuild.configure.os=x86_64-w64-mingw32 stage 
(32-bit Windows): ant -Dbuild.configure.os=i686-w64-mingw32 stage 

Les fichiers JAR seront dans le répertoire/dist/lib.

Si vous avez besoin des binaires Linux pour fonctionner en plus sur CentOS, vous devez maintenant changer la version de GCC et G ++ pour utiliser 3.4 au lieu de 3.6.

Installer GCC 4.4:

apt-get install gcc-4.4 

Mise à jour des liens symboliques à utiliser 4.4 (le lien spécifique à arc sera différent sur 32 bits VM):

rm /usr/bin/gcc 
ln -s /usr/bin/gcc-4.4 /usr/bin/gcc 
rm /usr/bin/x86_64-linux-gnu-gcc 
ln -s /usr/bin/x86_64-linux-gnu-gcc-4.4 /usr/bin/x86_64-linux-gnu-gcc 

Installer C++ (G ++) 4.4 :

apt-get install c++-4.4 

Mise à jour des liens symboliques à utiliser 4.4 (le lien spécifique à arc sera différent sur VM 32 bits):

rm /usr/bin/cpp 
ln -s /usr/bin/cpp-4.4 /usr/bin/cpp 
rm /usr/bin/x86_64-linux-gnu-cpp 
ln -s /usr/bin/x86_64-linux-gnu-cpp-4.4 /usr/bin/x86_64-linux-gnu-cpp 
rm /usr/bin/g++ 
ln -s /usr/bin/g++-4.4 /usr/bin/g++ 
rm /usr/bin/x86_64-linux-gnu-g++ 
ln -s /usr/bin/x86_64-linux-gnu-g++-4.4 /usr/bin/x86_64-linux-gnu-g++ 

Vérifiez les versions par défaut:

gcc --version 
c++ --version 
cpp --version 
gcc --version 

Vous pouvez maintenant exécuter les builds de la même manière qu'auparavant (il vous suffit de re-construire les binaires Linux). Les binaires seront désormais compatibles avec les versions légèrement plus anciennes de nombreuses distributions Linux (y compris la compatibilité CentOS). Ces binaires compilés 4.4 devraient toujours fonctionner partout où les versions 4.6 compilées fonctionneraient aussi.

Un merci spécial à this blog pour me pointer dans la bonne direction et en me donnant la majorité de ce que j'ai détaillé ci-dessus.