Desenvolvedores

Se você é programador (ou quer se tornar um) e está interessado em desenvolver novos recursos, corrigir bugs ou melhorar a interface do usuário do OpenShot, as seções a seguir explicarão como começar e se envolver!

A Visão Geral

O OpenShot Video Editor possui 3 componentes principais: uma interface de usuário em Python & PyQt (openshot-qt), uma biblioteca de áudio em C++ (libopenshot-audio) e uma biblioteca de vídeo em C++ (libopenshot). Se você não está familiarizado com Python, PyQt ou C++, esses seriam ótimos tópicos para pesquisar e aprender mais neste momento.

No entanto, muitos bugs podem ser corrigidos e novos recursos adicionados apenas com conhecimento em Python, já que os componentes em C++ não estão envolvidos na interface do usuário. Python é uma linguagem incrível, muito divertida de aprender, e é a única habilidade pré-requisito para se tornar um desenvolvedor do OpenShot!

Aviso

As instruções a seguir são para Ubuntu Linux, que é o ambiente mais fácil de configurar para desenvolvimento do OpenShot. Se você estiver usando outro sistema operacional, sugiro executar uma máquina virtual com Ubuntu LTS antes de continuar.

Se você precisar usar um sistema Windows ou Mac para desenvolvimento, comece consultando as notas de compilação na wiki do libopenshot. Compilar a biblioteca com todas as suas dependências é a parte mais desafiadora do processo.

Obtendo o Código Fonte Mais Recente

Antes de corrigirmos qualquer bug ou adicionarmos recursos, precisamos obter o código fonte no seu computador.

Use git para clonar nossos 3 repositórios:

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

Configurando seu Ambiente de Desenvolvimento

Para compilar ou executar o OpenShot, precisamos instalar algumas dependências no seu sistema. A maneira mais fácil de fazer isso é com nosso Daily PPA. Um PPA é um repositório não oficial do Ubuntu, que disponibiliza nossos pacotes de software para download e instalação.

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

O OpenShot suporta PyQt5, PyQt6 e PySide6. O libopenshot deve ser compilado contra a versão correta do Qt para a ligação que você está usando (Qt5: PyQt5, Qt6: PyQt6 ou PySide6).

Para as ligações PySide6 (Qt6), instale estes pacotes:

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

Para PyQt6, instale estes pacotes:

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

O tempo de execução PyQt6 deve fornecer QtCore, QtGui, QtWidgets, QtSvg, QtStateMachine e uic. Algumas distribuições dividem esses módulos em pacotes separados. Em particular, o pacote python3-pyqt6 do Ubuntu 24.04 não inclui QtStateMachine. Nessa versão, use os pacotes PySide6 acima ou instale o pacote completo PyQt6 wheel em um ambiente virtual Python:

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

Verifique a ligação Qt selecionada e seus módulos necessários antes de iniciar o OpenShot:

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

Neste ponto, você deve ter o código fonte dos 3 componentes do OpenShot clonados em pastas locais, o PPA diário do OpenShot instalado e todas as dependências de desenvolvimento e execução necessárias instaladas. Este é um ótimo começo, e agora estamos prontos para começar a compilar código!

libopenshot-audio (Instruções de Compilação)

Esta biblioteca é necessária para reprodução de áudio e efeitos sonoros. É baseada no framework de áudio JUCE. Aqui estão os comandos para compilá-la:

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

Basicamente, estamos mudando para a pasta libopenshot-audio/build, depois executando cmake .. na pasta pai. Isso encontra as dependências e cria todos os Makefiles necessários para compilar esta biblioteca. Em seguida, make usa esses Makefiles para compilar a biblioteca, e make install instala os arquivos no local especificado. Se CMAKE_INSTALL_PREFIX não estiver definido, os arquivos serão instalados em /usr/local/ (por padrão) e make install exigirá privilégios administrativos para ser executado.

libopenshot (Instruções de Compilação)

Esta biblioteca é necessária para decodificação, codificação, animação de vídeo e praticamente tudo mais. Ela realiza a maior parte do trabalho pesado da edição e reprodução de vídeo. Aqui estão os comandos para compilá-la:

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

Basicamente, estamos mudando para a pasta libopenshot/build, depois executando cmake .. na pasta pai. Isso encontra as dependências e cria todos os Makefiles necessários para compilar esta biblioteca. Em seguida, make usa esses Makefiles para compilar a biblioteca. Como fornecemos o local da instalação compilada do libopenshot-audio, essa versão da biblioteca será usada em vez da versão do sistema (se houver).

Não instalamos nosso libopenshot após a compilação, porque não é necessário. Para fins de teste, podemos instruir o OpenShot a usar o libopenshot diretamente do nosso diretório build.

Bindings de Linguagem

A API do libopenshot está disponível em várias linguagens através de bindings SWIG. Python é usado pela interface do OpenShot, e também fornecemos bindings para Ruby e Java. Suporte experimental para Godot 4.4 está incluído para desenvolvedores que desejam integrar recursos de edição de vídeo no motor de jogos Godot. Todos esses bindings mapeiam para a mesma base de código C++, permitindo que você edite vídeos no ambiente que preferir.

openshot-qt (Instruções de Execução)

Este é nosso aplicativo principal em PyQt Python. Como é escrito em Python, não requer compilação para ser executado. Para iniciar o OpenShot a partir do código fonte com nossas bibliotecas libopenshot-audio e libopenshot recém-compiladas, use os seguintes comandos:

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

Isto deve iniciar a interface do usuário do OpenShot. Quaisquer alterações que você tenha feito nos arquivos de código-fonte (arquivos Python *.py, arquivos PyQt UI *.ui, etc…) serão incluídas. Isso requer as bibliotecas libopenshot-audio e libopenshot, e se algo deu errado com os passos acima, provavelmente o OpenShot não será iniciado.

Se o OpenShot iniciar neste ponto, parabéns! Você agora tem uma versão local funcional do OpenShot, que está rodando a partir do seu código-fonte local. Tente fazer algumas alterações no código-fonte e reinicie o OpenShot… você deverá ver suas alterações agora!

Opções de Linha de Comando

Estas opções funcionam com o aplicativo OpenShot instalado, incluindo openshot-qt.exe no Windows. Ao executar a partir do código-fonte, use python3 src/launch.py no lugar do nome do aplicativo. Coloque as opções antes de quaisquer caminhos de arquivo que você deseja que o OpenShot abra.

Opções de linha de comando do OpenShot
Opção	O que faz
`-h`, `--help`	Mostra as opções disponíveis e sai.
`-V`, `--version`	Exibe a versão do OpenShot e sai.
`-l CODE`, `--lang CODE`	Use o idioma da interface escolhido para esta inicialização. O código deve ser um dos mostrados por `--list-languages`.
`--list-languages`	Lista os códigos de idiomas suportados e sai.
`--path FOLDER`	Adiciona uma pasta ao caminho de busca de módulos Python. Você pode repetir esta opção para adicionar mais de uma pasta.
`--feedback-preview`	Mostra o aviso de feedback na inicialização sem marcar o convite como exibido nas configurações salvas.
`--update-preview`	Mostra o aviso de atualização na inicialização. Ambas as opções de pré-visualização podem ser usadas juntas.
`--test-models`	Ativa o testador de modelo de dados do Qt para desenvolvimento (requer Qt 5.11 ou superior).
`-d`, `--debug`, `--debug-ui`	Adiciona mensagens detalhadas da interface ao arquivo de log e ao terminal.
`--debug-engine`	Adiciona mensagens detalhadas do motor de vídeo e áudio ao arquivo de log e ao terminal.
`--log-level LEVEL`	Define o nível de registro para ambas as partes do OpenShot, em arquivos e no terminal.
`--log-file-level LEVEL`	Define o nível de registro em ambos os arquivos de log.
`--log-console-level LEVEL`	Define o nível de registro no terminal para ambas as partes do OpenShot.
`--debug-file`	Adiciona mensagens detalhadas da interface apenas ao arquivo de log. Esta opção antiga é aceita, mas não é mostrada pelo `--help`.
`--debug-console`	Adiciona mensagens detalhadas da interface apenas ao terminal. Esta opção antiga é aceita, mas não é mostrada pelo `--help`.
`PROJECT.osp` ou caminhos de arquivos de mídia	Abre um projeto quando o primeiro caminho de arquivo termina em `.osp`. Caso contrário, inicia um novo projeto e importa os arquivos de mídia fornecidos.

Para LEVEL, use debug, info, warning, error, critical ou off. Veja Usando Logs para Solucionar um Problema para locais dos arquivos de log, exemplos e mais sobre como escolher opções de registro.

Problemas no GitHub

Agora que você compilou e iniciou com sucesso o OpenShot Video Editor a partir do código-fonte, não deixe de conferir nossa lista de relatórios de bugs no GitHub: OpenShot Issues. Além disso, você é incentivado a preencher nosso rápido formulário de colaborador e se apresentar!