Développeurs

Si vous êtes programmeur (ou souhaitez le devenir) et que vous souhaitez développer de nouvelles fonctionnalités, corriger des bugs ou améliorer l’interface utilisateur d’OpenShot, les sections suivantes expliquent comment commencer et participer !

Le tableau d’ensemble

OpenShot Video Editor comprend 3 composants principaux : une interface utilisateur Python & PyQt (openshot-qt), une bibliothèque audio C++ (libopenshot-audio) et une bibliothèque vidéo C++ (libopenshot). Si vous ne connaissez pas Python, PyQt ou C++, ce sont d’excellents sujets à étudier et à approfondir à ce stade.

Cependant, de nombreux bugs peuvent être corrigés et de nouvelles fonctionnalités ajoutées avec uniquement des connaissances en Python, car les composants C++ ne sont pas du tout impliqués dans l’interface utilisateur. Python est un langage incroyable, très amusant à apprendre, et c’est la seule compétence requise pour devenir développeur OpenShot !

Avertissement

Les instructions qui suivent concernent Ubuntu Linux, qui est l’environnement le plus simple à configurer pour le développement d’OpenShot. Si vous utilisez un autre système d’exploitation, je vous suggère d’exécuter une machine virtuelle avec Ubuntu LTS avant de continuer.

Si vous devez utiliser un système Windows ou Mac pour le développement, commencez par consulter les notes de compilation dans le wiki libopenshot. La compilation de la bibliothèque avec toutes ses dépendances est la partie la plus difficile du processus.

Obtenir le code source le plus récent

Avant de pouvoir corriger des bugs ou ajouter des fonctionnalités, nous devons récupérer le code source sur votre ordinateur.

Utilisez git pour cloner nos 3 dépôts :

git clone https://github.com/OpenShot/libopenshot-audio.git
git clone https://github.com/OpenShot/libopenshot.git
git clone https://github.com/OpenShot/openshot-qt.git

Configurer votre environnement de développement

Pour pouvoir compiler ou exécuter OpenShot, nous devons installer certaines dépendances sur votre système. La façon la plus simple d’y parvenir est d’utiliser notre PPA quotidien. Un PPA est un dépôt Ubuntu non officiel, qui propose nos paquets logiciels à télécharger et installer.

sudo add-apt-repository ppa:openshot.developers/libopenshot-daily
sudo apt-get update
sudo apt-get install openshot-qt \
                     build-essential \
                     cmake \
                     catch2 \
                     libx11-dev \
                     libasound2-dev \
                     libavcodec-dev \
                     libavdevice-dev \
                     libavfilter-dev \
                     libavformat-dev \
                     libavresample-dev \
                     libavutil-dev \
                     libfdk-aac-dev \
                     libfreetype6-dev \
                     libjsoncpp-dev \
                     libmagick++-dev \
                     libopenshot-audio-dev \
                     libprotobuf-dev \
                     libqt5svg5-dev \
                     libswscale-dev \
                     libunittest++-dev \
                     libxcursor-dev \
                     libxinerama-dev \
                     libxrandr-dev \
                     pkg-config \
                     python3-dev \
                     protobuf-compiler \
                     qtbase5-dev \
                     libqt5svg5-dev \
                     libxcb-xfixes0-dev \
                     qtmultimedia5-dev \
                     swig

OpenShot prend en charge PyQt5, PyQt6 et PySide6. libopenshot doit être compilé avec la bonne version de Qt correspondant au binding que vous utilisez (Qt5 : PyQt5, Qt6 : PyQt6 ou PySide6).

Pour les bindings PySide6 (Qt6), installez ces paquets :

sudo apt-get install \
                     python3-pyside6.qtcore \
                     python3-pyside6.qtgui \
                     python3-pyside6.qtwidgets \
                     python3-pyside6.qtstatemachine \
                     python3-pyside6.qtsvg \
                     python3-pyside6.qtuitools \
                     shiboken6

Pour PyQt6, installez ces paquets :

sudo apt-get install \
                     qt6-base-dev \
                     qt6-base-dev-tools \
                     qt6-tools-dev \
                     qt6-svg-dev

Le runtime PyQt6 doit fournir QtCore, QtGui, QtWidgets, QtSvg, QtStateMachine et uic. Certaines distributions divisent ces modules en paquets séparés. En particulier, le paquet python3-pyqt6 d’Ubuntu 24.04 n’inclut pas QtStateMachine. Sur cette version, utilisez les paquets PySide6 ci-dessus ou installez la roue PyQt6 complète dans un environnement virtuel Python :

python3 -m venv .venv
.venv/bin/python -m pip install PyQt6

Vérifiez le binding Qt sélectionné et ses modules requis avant de lancer OpenShot :

PYTHONPATH=src OPENSHOT_QT_API=pyqt6 .venv/bin/python -c \
    "from qt_api import QT_API, QStateMachine; print(QT_API, QStateMachine)"

À ce stade, vous devriez avoir cloné le code source des 3 composants OpenShot dans des dossiers locaux, installé le PPA quotidien d’OpenShot, et installé toutes les dépendances nécessaires au développement et à l’exécution. C’est un excellent début, et nous sommes maintenant prêts à commencer à compiler du code !

libopenshot-audio (Instructions de compilation)

Cette bibliothèque est nécessaire pour la lecture audio et les effets audio. Elle est basée sur le framework audio JUCE. Voici les commandes pour la compiler :

cd libopenshot-audio
mkdir build
cd build
cmake -DCMAKE_INSTALL_PREFIX=dist ..
make
make install

Essentiellement, nous passons dans le dossier libopenshot-audio/build, puis exécutons cmake .. sur le dossier parent. Cela détecte les dépendances et crée tous les Makefiles nécessaires à la compilation de cette bibliothèque. Ensuite, make utilise ces Makefiles pour compiler la bibliothèque, et make install l’installe à l’emplacement spécifié. Si CMAKE_INSTALL_PREFIX n’est pas défini, les fichiers seront installés par défaut dans /usr/local/ et make install nécessitera des privilèges administratifs.

libopenshot (Instructions de compilation)

Cette bibliothèque est nécessaire pour le décodage, l’encodage vidéo, l’animation, et presque tout le reste. Elle effectue tout le travail lourd du montage vidéo et de la lecture vidéo. Voici les commandes pour la compiler :

cd libopenshot
mkdir build
cd build
cmake -DLIBOPENSHOT_AUDIO_DIR=../../libopenshot-audio/build/dist ..
make

Essentiellement, nous passons dans le dossier libopenshot/build, puis exécutons cmake .. sur le dossier parent. Cela détecte les dépendances et crée tous les Makefiles nécessaires à la compilation de cette bibliothèque. Ensuite, make utilise ces Makefiles pour compiler la bibliothèque. Comme nous avons indiqué l’emplacement de notre installation compilée de libopenshot-audio, cette version sera utilisée à la place de la version système (le cas échéant).

Nous n’installons pas notre libopenshot après la compilation, car ce n’est pas nécessaire. Pour les tests, nous pouvons indiquer à OpenShot d’utiliser libopenshot directement depuis notre dossier build.

Liaisons de langage

L’API libopenshot est disponible dans plusieurs langages via des liaisons SWIG. Python est utilisé par l’interface utilisateur d’OpenShot, et nous fournissons également des liaisons Ruby et Java. Un support expérimental pour Godot 4.4 est inclus pour les développeurs souhaitant intégrer des fonctionnalités de montage vidéo dans le moteur de jeu Godot. Toutes ces liaisons correspondent à la même base de code C++, vous permettant d’éditer des vidéos depuis l’environnement de votre choix.

openshot-qt (Instructions de lancement)

C’est notre application principale PyQt en Python. Étant écrit en Python, il ne nécessite aucune compilation pour s’exécuter. Pour lancer OpenShot depuis le code source avec nos bibliothèques libopenshot-audio et libopenshot nouvellement compilées, utilisez les commandes suivantes :

cd openshot-qt
PYTHONPATH=../libopenshot/build/src/bindings/python
python3 src/launch.py

Cela devrait lancer l’interface utilisateur d’OpenShot. Toutes les modifications que vous avez apportées aux fichiers source (fichiers Python *.py, fichiers UI PyQt *.ui, etc.) seront incluses. Cela nécessite les bibliothèques libopenshot-audio et libopenshot, et si quelque chose a mal tourné lors des étapes précédentes, OpenShot ne se lancera probablement pas.

Si OpenShot se lance à ce stade, félicitations ! Vous disposez maintenant d’une version locale fonctionnelle d’OpenShot, qui s’exécute à partir de votre code source local. Essayez de modifier le code source et de relancer OpenShot… vous devriez maintenant voir vos modifications !

Options en ligne de commande

Ces options fonctionnent avec l’application OpenShot installée, y compris openshot-qt.exe sous Windows. Lors de l’exécution depuis la source, utilisez python3 src/launch.py à la place du nom de l’application. Placez les options avant les chemins de fichiers que vous souhaitez ouvrir avec OpenShot.

Options en ligne de commande d’OpenShot
Option	Fonction
`-h`, `--help`	Afficher les options disponibles et quitter.
`-V`, `--version`	Afficher la version d’OpenShot et quitter.
`-l CODE`, `--lang CODE`	Utiliser la langue d’interface choisie pour ce lancement. Le code doit être l’un de ceux affichés par `--list-languages`.
`--list-languages`	Lister les codes de langue supportés et quitter.
`--path FOLDER`	Ajouter un dossier au chemin de recherche des modules Python. Vous pouvez répéter cette option pour ajouter plusieurs dossiers.
`--feedback-preview`	Afficher la notification de retour d’expérience au lancement sans marquer l’invitation comme affichée dans les paramètres enregistrés.
`--update-preview`	Afficher la notification de mise à jour au lancement. Les deux options de prévisualisation peuvent être utilisées ensemble.
`--test-models`	Activer le testeur de modèle de données de Qt pour le développement (nécessite Qt 5.11 ou ultérieur).
`-d`, `--debug`, `--debug-ui`	Ajouter des messages détaillés de l’interface au fichier journal et au terminal.
`--debug-engine`	Ajouter des messages détaillés du moteur vidéo et audio au fichier journal et au terminal.
`--log-level LEVEL`	Définir le niveau de journalisation pour les deux parties d’OpenShot, dans les fichiers et le terminal.
`--log-file-level LEVEL`	Définir le niveau de journalisation dans les deux fichiers journaux.
`--log-console-level LEVEL`	Définir le niveau de journalisation dans le terminal pour les deux parties d’OpenShot.
`--debug-file`	Ajouter des messages détaillés de l’interface uniquement au fichier journal. Cette ancienne option est acceptée mais n’est pas affichée par `--help`.
`--debug-console`	Ajouter des messages détaillés de l’interface uniquement au terminal. Cette ancienne option est acceptée mais n’est pas affichée par `--help`.
`PROJECT.osp` ou chemins de fichiers média	Ouvrir un projet lorsque le premier chemin de fichier se termine par `.osp`. Sinon, démarrer un nouveau projet et importer les fichiers média fournis.

Pour LEVEL, utilisez debug, info, warning, error, critical ou off. Voir Utiliser les journaux pour résoudre un problème pour les emplacements des fichiers journaux, des exemples et plus d’informations sur le choix des options de journalisation.

Problèmes GitHub

Maintenant que vous avez compilé et lancé avec succès OpenShot Video Editor à partir du code source, assurez-vous de consulter notre liste de rapports de bugs sur GitHub : OpenShot Issues. De plus, nous vous encourageons à remplir notre rapide formulaire de contributeur et à vous présenter !