About

• AlphaQ – BETAke – gammaQ v3 now deltaQ v4
• script karaoke:
• vocal enhanced effects,
• pitch correction,
• auto-download YouTube playbacks
• + final mix/video render
  https://github.com/guprobr/BETAKe

Karaoke video PLAYER with performance RECORDER for Linux.

• just a Shell script karaoke: vocal enhanced effects, pitch correction, auto-download YouTube playbacks + final mix/video render
• based on FFMpeg + LV2 plugins AlphaQ – BETAke – now gammaQ v3

DeltaQ° ŧħ3 B3TAKê ·v4·

Este é um script de shell para gravar e aprimorar performances de karaokê. Ele é usado para capturar a performance de karaokê de um usuário usando uma webcam e um microfone, combinar a performance com a faixa de áudio original e, em seguida, aplicar várias melhorias de áudio, como ajuste de volume e remoção de ruído.

Como usar

Configuração: Antes de usar o script, certifique-se de ter os seguintes requisitos instalados no seu sistema:

ffmpeg sox yad lv2file mplayer v4l-utils

No ubuntu é fácil:

Faça o clone do repositório e rode como SEU USUARIO NORMAL o arquivo ./instalar.sh

Um icone no gnome-shell vai surgir chamado BETAKe – gammaQ

para efeito de debug, existe um log pormenorizado script.log criado no diretório onde está o programa

na interface python há logs menos verbose.

Execução do Script: Execute o script PYTHON BETAKe.py no terminal, se precisar debugar, ou no gnome-shell, pois o instalar.sh cria um .desktop como dito. O script python3 é que vai fornecendo os seguintes argumentos para o shell principal gammaQ.sh:

• Nome da performance de karaokê
• URL do vídeo de karaokê
• Diretório do projeto
• Dispositivo de vídeo
• URL da sobreposição (opcional)
• Opção para pular a performance (0 ou 1)
• Outra opção (opcional) – duplicar ECHO
• Outra opção (opcional) – Pitch bend UP ou DOWN

Portanto um launcher, uma interface grafica para manipular o comando “gammaQ.sh”

Gravação da Performance:

O script inicia a gravação da performance de karaokê usando a webcam e o microfone especificados.

Melhorias de Áudio:

Após a gravação, o script aplica várias melhorias de áudio, como remoção de ruído, ajuste de volume e equalização.

Visualização e Renderização:

O usuário pode visualizar a performance aprimorada e, se estiver satisfeito, renderizar o vídeo final.

detecção de volume ideal

O script compara o volume dos vocais com o playback e sugere uma porcentagem de alteração. O usuário pode fazer um preview do mix inteiro e alterar conforme o volume de 0 a 100% para diminuir ou mais para aumentar.

• Converte o arquivo de playback para o formato WAV usando o ffmpeg.
• Verifica a validade do arquivo WAV convertido.
• Extrai as informações de volume (amplitude RMS) de ambos os arquivos de playback e de vocais.
• Calcula a diferença de volume em decibéis (dB) entre os arquivos de playback e de vocais.
• Transforma a diferença de volume em uma porcentagem para fornecer uma recomendação de ajuste base.

Filtros SoX (Sound eXchange):

Geração de perfil de ruído:

sox "${OUT_VOCAL}" -n trim 0 15 noiseprof "$OUT_DIR"/"$karaoke_name"/"${karaoke_name}".prof > lv2.tmp.log 2>&1

Redução de ruído:

sox "${OUT_VOCAL}" "${VOCAL_FILE}" noisered "$OUT_DIR"/"$karaoke_name"/"${karaoke_name}".prof 0.1 dither -s > lv2.tmp.log 2>&1

Filtros LV2 (LADSPA):

em breve docs!

Aplicação do plugin de desclipping:

lv2file -i "${VOCAL_FILE}" -o "${OUT_VOCAL}" http://plugin.org.uk/swh-plugins/declip > lv2.tmp.log 2>&1

Filtros ffmpeg:

em breve!

Conversão de vídeo para áudio WAV:

ffmpeg -i "${PLAYBACK_BETA}" "${PLAYBACK_BETA%.*}".wav

Processamento de áudio com filtros:

ffmpeg -i "${OUT_VOCAL}" -af ... "${VOCAL_FILE}"

Combinação de áudio e vídeo:

ffmpeg -i ... -filter_complex ... -map ... "${OUT_FILE}"

• uma série de filtros de video são aplicados, para criar boxes com o video do playback, a imagem do usuario cantando, efeitos visuais e mais alguns ajustes vocais, além do mix propriamente dito.
• após isso é gerada uma MP3 e o display do resultado final.

• Karaoke OUTPUT name: o nome do projeto, vai ser o nome do diretorio criado onde serao criados os sssets
• Playback Video URL: uma URL do Youtube, por exemplo, ou varios streamings suportados pelo yt-dlp. Ela sera baixada e armazenada, será disponibilizada na tela para o usuario cantar e depois no video final em um box separado.
• Overlay video: (opcional) um outro video para fetch que será sobreposto ao video do usuario, para efitos visuais.
• cfg /dev/videoX – seletor de arquivo de dispositivo v4l2 para a webcam
• NOTA: o microfone da gravação é selecionado pela source DEFAULT pulse/pipewire atual no launch do script,
• Just render, no rec: pula a gravação da performance e renderiza novamente o arquivo de projeto que estiver escrito na caixa de texto Karaoke Name
• SELECT: saved proj, overlay, playback: preenche as 3 caixas respectivamente com arquivos que ja existem no sistema de arquivos. Evita download.
• Get Fortune! – para efeito de descontrair, o programa pode falar mensagens do /usr/bin/fortunes UNIX no console da interface python.
• OPT-out fun effects: deixa o video do usuario na webcam cru, sem efeitos psicodélicos (que sáo meio exagerados por default)
• DOUBLE echo: normalmente o mix vai com um echo leve, nesse caso ele fica bem forçado. Ideal para músicas do Moby, etc.
• Pitch BEND up ou DOWN: faz um shift para cima ou para baixo da tonalidade dos vocais usando o XC 42
• FULL logs: para ver exatamente o que apareceria no console e não os logs simples da interface python3
• PLOT mic / CLOSE plot: um visualizador para testar o nivel em decibeis do vocal, ou seja, ajustar o microfone com precisão. Uma janela se abre e vc pode durante o karaoke tbm observar isso.
• Karaoke KILL: nao só um Quit mas tbm força matar caso algum processo fique preso. Talvez seja necessario apertar diversas vezes, nesses casos. Força na peruca.

Opções do Script

• Simula a execução do script sem realizar a gravação ou aprimoramento de áudio. Isso serve para não ter que cantar de novo apenas para ajustar algum parametro, assim rendereizando novamente com outros efeitos, ou overlays, ou até mesmo playbacks. Basta colocar o nome do projeto igual ao diretorio onde foi gravado (há um botao na interface para Saved PRoject)
• Duplicar o efeito de eco durante a gravação da performance.
• Pitch [UP|DOWN]: Define a direção do ajuste de tom durante a renderização do vídeo final.

Requisitos do Sistema Linux Bash Pacotes mencionados acima instalados

Sinta-se à vontade para contribuir com melhorias, relatar problemas ou propor novos recursos através de problemas e solicitações pull. Sinta-se à vontade para ajustar ou expandir esta documentação de acordo com as necessidades do seu projeto. Se precisar de mais alguma coisa ou tiver dúvidas, estou aqui para ajudar!

OPERA SUMMARY

Karaoke Bash Script – Turn Your Machine into a Karaoke Machine! This Bash script allows you to create your own karaoke videos with enhanced vocals!

Here’s what you can do:

• Download a karaoke video (playback) from a URL or use a local file.
• Optionally include an overlay video for additional effects.
• Capture your singing performance using your webcam and microphone.
• Create a combined MP4 video with your performance, the playback video (with adjusted volume), and the overlay video (if used).
• Enhance the captured audio to make your vocals stand out (functionality currently commented out).

Technical Details:

• The script utilizes FFmpeg for video processing and audio manipulation.
• It interacts with the user through colored messages and dialog boxes using the yad tool (installation required).
• PulseAudio or PipeWire is used for capturing audio from your microphone.

Getting Started:

Requirements:

• Bash shell
• FFmpeg (https://ffmpeg.org/download.html)
• yad (https://sourceforge.net/projects/yad-dialog/)
• PulseAudio or PipeWire (https://wiki.archlinux.org/title/PipeWire)

How it Works:

The script will guide you through a series of steps:

• Enter a name for your karaoke video (defaults to “BETA”).
• Provide the URL of the karaoke video or the path to a local video file.
• Specify where you want to save the final karaoke video.
• Select your webcam device.
• (Optional) Enter the URL of an overlay video.
• Choose whether to skip webcam capture (useful for editing existing recordings).
• (Optional) Choose whether to restore vocals from a previously saved audio file.
• Select if you want the vocals to be “bent”, shift pitch UP or DOWN.
• The script will then download the videos (if necessary), process the audio, and guide you through recording your performance. Finally, it combines everything into a finished karaoke video with your singing in the spotlight!

Note: The functionality for more enhanced vocals is currently commented out but can be potentially enabled in the future.

This script provides a fun and customizable way to create your own karaoke videos. Feel free to tinker with the code and explore its possibilities!

• Tonal correction algorithms in general aim to adjust the pitch or pitch of musical notes in an audio recording to ensure that they conform to a particular scale or tonal pattern. These algorithms are often used in audio editing software to correct pitch problems in vocal or instrumental performances.

The mathematical principle underlying tonal correction algorithms involves detecting the fundamental frequencies of musical notes in the audio recording and then applying transformations to adjust these frequencies to match a desired tonal scale. Here is a detailed explanation of the process:

• Detection of Fundamental Frequencies: The first step is to detect the fundamental frequencies of musical notes in the audio recording. This can be done using spectrum analysis techniques, such as the Fourier Transform, which allows you to decompose the audio signal into its frequency components.
• Correlation with Tonal Scale: Once the fundamental frequencies are identified, they are correlated with a desired tonal scale. This may involve comparing the detected frequencies with the intervals of the musical scale to determine which notes are being played or sung.
• Pitch Deviation Calculation: Based on the correlation with the tonal scale, the pitch deviation of each note in relation to the desired scale is calculated. This is done by comparing the detected frequencies to the standard frequencies of the notes in the tonal scale.
• Application of Transformations: With the pitch deviation determined for each note, transformations are applied to adjust their frequencies. This may involve transposing frequencies up or down to match the correct pitch of the note on the tonal scale.
• Transition Smoothing: To ensure that transitions between adjusted notes sound natural, interpolation techniques such as linear interpolation or spline interpolation are applied to smooth out frequency changes over time.
• Audio Reprocessing and Synthesis: After adjusting the frequencies, the audio is reprocessed and synthesized to create a new version of the recording with the tonal corrections applied. This may involve overlaying the adjusted notes over the original recording or synthesizing new sounds based on the applied corrections.

This is a simplified summary of the mathematical principle behind tonal correction algorithms. In practice, these algorithms can be quite complex and incorporate a variety of audio signal processing and mathematical modeling techniques to obtain accurate and natural results.

this COMPLETE SONNET, in stages:

The Python interface constantly receives updates and new features, but it is the shell script that really does the application’s work. This shell script goes through a series of steps to improve vocal quality in a karaoke recording. Let’s look at each of these steps in detail:

Karaoke Video Download:

Using the yt-dlp tool, the script downloads the karaoke video from the provided URL. The video is then renamed and stored locally.

Audio and Video Recording:

The script begins by capturing audio and video input from a source, such as a webcam, while the karaoke video plays. This is done by using FFmpeg to record input video and audio simultaneously.

Audio Processing:

After recording, the voice audio is separated from the video and goes through several processing steps: First, the audio is noise profiled to identify and remove background noise. Next, a tonal correction algorithm is applied using the Gareus XC42 and Auburn Sound’s Graillon plugin, with volume and equalization adjustments to improve vocal quality. If the audio has clipping problems, a declipper is used to correct these problems. Finally, the processed audio is combined with the audio from the original video.

Final Video Rendering:

After processing the audio, the video is readjusted to synchronize with the processed audio. The delay or advance time is calculated based on the difference in duration between the audio and video recording. The final rendering combines the original video with the processed audio, applying text to the screen to display the remaining time of the song. The resulting video is then saved.

MP3 Output File Generation:

In addition to the final video, the script also generates a separate MP3 audio file from the final output file. This allows users to have an audio-only version of the karaoke recording.

Displaying the Video to the User:

Finally, the final video is played back to the user using FFplay, allowing them to preview the final result of the karaoke recording. In terms of the quality of the approach, This shell script presents a series of techniques for improving vocal quality, including noise reduction, tonal correction and equalization. However, the effectiveness of these techniques may vary depending on the quality of the original recording and the precision of the algorithms used, being constantly improved, seeking not to exaggerate the resources but rather to build a direct solution, which does not require subtractions from a larger set along the way.

XC 42:

XC 42 is another tonal correction algorithm, developed by Joshua Reiss and Andrew McLeod. It uses advanced audio signal processing techniques to perform tonal correction on vocal recordings. The XC 42 is designed to provide accurate and efficient tonal correction, with control over parameters such as the extent of correction and the smoothing of transitions between musical notes.

Graillon:

Graillon is a machine learning-based tonal correction tool developed by Grzegorz Ptasinski. It uses advanced audio signal processing algorithms and machine learning techniques to perform tonal correction on high-quality audio recordings. The Graillon is known for its ability to correct pitches precisely and naturally, adapting to the vocal style and nuances of the singer’s performance. I’ve decided to remove Graillon for a moment, because it is proprietary.

Shibata Dithering and Noise Reduction via SoX:

Shibata Dithering is a dithering method used to improve digital audio quality. In the context of scripting, it is applied using SoX (Sound eXchange), a powerful audio processing tool.

The line

sox "${VOCAL_FILE}" -n trim 0 5 noiseprof "$OUT_DIR"/"$karaoke_name".prof

creates a noise profile from the first 5 seconds of the previously generated audio file. Right away,

sox "${VOCAL_FILE}" "${OUT_VOCAL}" noisered "$OUT_DIR"/"$karaoke_name".prof 0.2 dither -s -f shibata

applies noise reduction using the created noise profile and applies Shibata Dithering to improve audio quality.

Gareus XC42 Vocal Tuning Algorithm:

Gareus XC42 is a vocal tuning algorithm developed by Robin Gareus. It is used to adjust and enhance the quality of voices in audio recordings. We use the lv2file tool to efficiently and flexibly apply the filter separately.

The line

lv2file -i "${OUT_VOCAL}" -o "${VOCAL_FILE}" -P Live http://gareus.org/oss/lv2/fat1

applies this algorithm to the vocal audio file, generating a new, enhanced audio file.

• These algorithms are applied to improve vocal audio quality, reduce noise and adjust specific characteristics of the voice to produce a more pleasant and professional end result.
• Each algorithm has its own function and settings that can be adjusted to meet the specific needs of a karaoke recording. A generic balance was sought that could maintain the naturalness of the result but also serve the purpose of improving the original recording.

post production with FFMpeg

Here the last filters are applied to clean the audio and finally mix with the downloaded playback. Synchronization is guaranteed from recording, where there is a mechanism to only trigger playback for the user when the file is confirmed to be written by FFMpeg. There is also a diff_ss variable that guarantees a forced synchronization adjustment in terms of nanoseconds. It is calculated by the difference in value in Unix Epoch nanoseconds at the start of execution of each process, $epoch_ff and $epoch_ffplay, using the date format %s.%N

preview and mp3

• after all this, FFMpeg is invoked again to create an overlay or xstack of the user filmed with the videos with effects and playback. The program then, if everything went well, plays the final file for preview;
• as a courtesy we generated an MP3 of the performance!
• everything is written to the ./outputs directory
• downloaded playbacks are cached in ./recordings

installation

partially implemented

• before running I recommend looking at install.sh to evaluate package requirements, python, etc.;
• BETAKe.py is the interface itself, there are few python library requirements. This one calls the main shell script gammaQ.sh
• I must have already placed most of the requirements in the installer.

lame DEMOs by Guzpido

https://Xiclet.com.br

PORTUGUESE DOCS

RESUMO DA OPERA

Os algoritmos de correção tonal em geral têm o objetivo de ajustar a afinação ou a altura das notas musicais em uma gravação de áudio para garantir que elas estejam em conformidade com uma determinada escala ou padrão tonal. Esses algoritmos são frequentemente usados em softwares de edição de áudio para corrigir problemas de afinação em performances vocais ou instrumentais.

O princípio matemático subjacente aos algoritmos de correção tonal envolve a detecção das frequências fundamentais das notas musicais na gravação de áudio e, em seguida, a aplicação de transformações para ajustar essas frequências para correspondência com uma escala tonal desejada. Aqui está uma explicação detalhada do processo:

• Detecção de Frequências Fundamentais: O primeiro passo é detectar as frequências fundamentais das notas musicais na gravação de áudio. Isso pode ser feito usando técnicas de análise de espectro, como a Transformada de Fourier, que permite decompor o sinal de áudio em suas componentes de frequência.
• Correlação com Escala Tonal: Uma vez que as frequências fundamentais são identificadas, elas são correlacionadas com uma escala tonal desejada. Isso pode envolver a comparação das frequências detectadas com os intervalos da escala musical para determinar quais notas estão sendo tocadas ou cantadas.
• Cálculo do Desvio de Afinação: Com base na correlação com a escala tonal, é calculado o desvio de afinação de cada nota em relação à escala desejada. Isso é feito comparando as frequências detectadas com as frequências padrão das notas na escala tonal.
• Aplicação de Transformações: Com o desvio de afinação determinado para cada nota, são aplicadas transformações para ajustar suas frequências. Isso pode envolver a transposição das frequências para cima ou para baixo para corresponder à afinação correta da nota na escala tonal.
• Suavização de Transições: Para garantir que as transições entre as notas ajustadas soem naturais, são aplicadas técnicas de interpolação, como interpolação linear ou interpolação por splines, para suavizar as mudanças de frequência ao longo do tempo.
• Reprocessamento e Síntese de Áudio: Após o ajuste das frequências, o áudio é reprocessado e sintetizado para criar uma nova versão da gravação com as correções tonais aplicadas. Isso pode envolver a sobreposição das notas ajustadas sobre a gravação original ou a síntese de novos sons com base nas correções aplicadas.

Este é um resumo simplificado do princípio matemático por trás dos algoritmos de correção tonal. Na prática, esses algoritmos podem ser bastante complexos e incorporar uma variedade de técnicas de processamento de sinais de áudio e modelagem matemática para obter resultados precisos e naturais.

este SONETO COMPLETO, por etapas:

A interface python constantemente recebe atualizações e novas features, mas é o shell script que realmente faz o trabalho da aplicação. Este script shell aborda uma série de etapas para melhorar a qualidade vocal em uma gravação de karaokê. Vamos analisar cada uma dessas etapas em detalhes:

Download do Vídeo de Karaokê:

Utilizando a ferramenta yt-dlp, o script faz o download do vídeo de karaokê da URL fornecida. O vídeo é então renomeado e armazenado localmente.

Gravação de Áudio e Vídeo:

O script começa capturando a entrada de áudio e vídeo de uma fonte, como uma webcam, enquanto o vídeo de karaokê é reproduzido. Isso é feito usando o FFmpeg para gravar a entrada de vídeo e áudio simultaneamente.

Processamento de Áudio:

Após a gravação, o áudio da voz é separado do vídeo e passa por várias etapas de processamento: Primeiramente, o áudio é submetido a um perfil de ruído para identificar e remover o ruído de fundo. Em seguida, é aplicado um algoritmo de correção tonal usando o plugin Gareus XC42 e Auburn Sound’s Graillon, com ajustes de volume e equalização para melhorar a qualidade vocal. Se o áudio apresentar problemas de clipping, é utilizado um declipper para corrigir esses problemas. Finalmente, o áudio processado é combinado com o áudio do vídeo original.

Renderização do Vídeo Final:

Após o processamento do áudio, o vídeo é reajustado para sincronizar com o áudio tratado. O tempo de atraso ou adiantamento é calculado com base na diferença de duração entre a gravação do áudio e do vídeo. A renderização final combina o vídeo original com o áudio tratado, aplicando texto na tela para exibir o tempo restante da música. O vídeo resultante é então salvo.

Geração de Arquivo de Saída MP3:

Além do vídeo final, o script também gera um arquivo de áudio MP3 separado a partir do arquivo de saída final. Isso permite que os usuários tenham uma versão apenas de áudio da gravação de karaokê.

Exibição do Vídeo para o Usuário:

Por fim, o vídeo final é reproduzido para o usuário usando o FFplay, permitindo que eles visualizem o resultado final da gravação de karaokê. Em termos de qualidade da abordagem, este script shell apresenta uma série de técnicas para melhorar a qualidade vocal, incluindo redução de ruído, correção tonal e equalização. No entanto, a eficácia dessas técnicas pode variar dependendo da qualidade da gravação original e da precisão dos algoritmos utilizados, estando em constante aperfeiçoamento, buscando não exagerar nos recursos mas sim construir uma solução direta, que não obrigue subtrações de um conjunto maior no percurso.

XC 42:

O XC 42 é outro algoritmo de correção tonal, desenvolvido por Joshua Reiss e Andrew McLeod. Ele usa técnicas avançadas de processamento de sinais de áudio para realizar correção tonal em gravações vocais. O XC 42 é projetado para oferecer correção tonal precisa e eficiente, com controle sobre parâmetros como a extensão de correção e a suavização de transições entre notas musicais.

preview e mp3

• após tudo isso, novamente se invoca o FFMpeg para criar um overlay ou xstack do usuário filmado com os vídeos com efeitos e o playback. O programa então se tudo deu certo, toca o arquivo final para preview;
• por cortesia geramos uma MP3 da performance!
• tudo é gravado no diretório ./outputs
• os playbacks baixados ficam em cache em ./recordings

instalação

parcialmente implementada

• antes de rodar recomendo olhar o instalar.sh para avaliar os requisitos de pacotes, python, etc;
• BETAKe.py é a interface em si, são poucos requisitos de biblioteca python. Este que chama o script shell principal gammaQ.sh
• a maioria dos requisitos já devo ter colocado no instalador.

DEMOs fuleiros by Guzpido:

em Son of a Preacher Man OUÇA a voz sem nenhum tratamento

E após o filtro BETAKê v1.7a

V2.6

PARA RODAR: use o python3

python3 BETAKe.py

Insira uma ID unica para seu karaoke, eu normalmente coloco o primeiro nome da música em maiúsculo.

Insira a URL do vídeo que vamos extrair para cantar junto como playback.

Overall, betaREC.sh sets up the environment for live recording with effects applied, while betaKE.sh performs post-processing to enhance the recorded audio and video. Together, they provide a comprehensive solution for karaoke recording.

betaREC.sh

This script sets up live audio processing with Autotalent pitch correction, dynamics processing, and equalization using PulseAudio’s pactl utility, and records to a filename with name followed by _voc.wav, every time you run it overwrites again. This is file is used by next script, which generates the final video.

Vamos documentar os filtros LADSPA e PulseAudio usados no primeiro script, betaREC.sh, e explicar como o vídeo do YouTube é baixado.

Filtros LADSPA:
declip_1195:
Este plugin é utilizado para remover a distorção de clipagem do áudio. Ele suaviza os picos de áudio que ultrapassam o limite de amplitude, resultando em um som menos distorcido.
tap_pitch:
Este plugin é usado para ajustar o tom do áudio, o que é útil em karaoke para corrigir pequenos desvios de afinação na voz. Os parâmetros controlam o ajuste do tom: o primeiro e o segundo controlam o tom em semitons e centavos, respectivamente, enquanto os terceiro, quarto e quinto controlam o deslocamento do volume.
Módulos PulseAudio:
module-echo-cancel:
Este módulo é carregado para cancelar o eco do áudio, especialmente do retorno de áudio proveniente do loopback. Isso ajuda a melhorar a qualidade do áudio, removendo ecos indesejados.
module-loopback:
Este módulo é carregado para criar um loopback de áudio, permitindo que o áudio seja redirecionado de uma fonte de entrada para uma fonte de saída. No contexto do script, é usado para redirecionar o áudio processado de volta para o sistema de áudio para reprodução.

Baixando o Vídeo do YouTube: O script utiliza a ferramenta yt-dlp para baixar o vídeo do YouTube. Aqui está como funciona:

Obtenção do Título do Vídeo:
Primeiro, o script usa yt-dlp --get-title para obter o título do vídeo do YouTube fornecido como argumento. Isso é feito para exibir informações sobre o vídeo que está sendo baixado.
Download do Vídeo:
Em seguida, o script usa yt-dlp novamente para baixar o vídeo do YouTube. Ele especifica a opção --embed-subs para incorporar legendas se estiverem disponíveis e --progress para exibir o progresso do download.
Conversão para WAV:
Depois que o vídeo é baixado, o script utiliza o ffmpeg para extrair o áudio do vídeo baixado e convertê-lo para o formato WAV. Isso é necessário para processamento adicional e gravação posterior.

Essas etapas permitem que o script baixe vídeos do YouTube, extraia o áudio e o prepare para gravação, permitindo a criação de karaokês com playback instrumental de alta qualidade e legendas embutidas, se disponíveis. Existem muitos canais hoje em dia, como ZOOM, KaraFun, ou até mesmo covers independentes instrumentais. Na verdade você pode usar esse programa vom qualquer vídeo.

betaKE.sh

• betaKE.sh is the post-processing script that renders a final MP4 video
• Now some enhancemente live, during recording time, except autotalent;
• we just have to enhance already pitch corrected vocal with effects in order to masterize:
• then MASTERIZE for streaming both playback and enhanced vocals, mixing both tracks.
• esses scripts focam ser o mais simples possível,
• tenha em mente, que, quanto mais se tenta efeitos sonoros mirabolantes, mais fácil estragar o audio final.

DE FORMA ALGUMA ISSO já é UMA APLICAÇÃO PARA USUÁRIO FINAL!

• Para flexibilidade, separei em dois scripts.
• Os playbacks devem ser formato WAV de preferencia nao ADPCM Microsoft.
• Coloque os playback na mesma pasta, ex, “We_are_the_Champions.wav”
• Nunca grave sem fones de ouvido, pois não é para gravar a saída do playback no arquivo da voz.
• O arquivo de voz gravado passa por processos de transformação e filtros, que o timbre dos instrumentos não é válido para o algoritmo.
• o princípio de todo bom resultado é ajustar o volume do microfone
• volume de input mto alto vai distorcer sua voz
• gritar não é cantar, mas se quiser pode, só vai ficar ruim seu karaoke
• teste antes de pegar o jeito, o volume do microfone em si que resulta numa voz decente
• depois também ajuste o volume do playback se necessario, isso é outra fonte de empecilhos para um bom resultado
• quando você roda o script yeah.sh ele aciona o módulo de loopback do input,
• para q você ouça sua própria voz quando estiver gravando
• também para ajustar antes de gravar definitivamente, sua voz o microfone em função do volume do playback

para gravar você usa:

betaREC.sh ID_SUA_MUSICA URL_VIDEO_KARAOKE:

This script is designed to set up and perform live recording with various effects applied, primarily for karaoke purposes. It will download a karaoke video, actually any video, and will mix the recording with the video original audio at the next step. Here’s a breakdown of its functionality:

Unload Existing Modules and Restart PulseAudio: T
his section unloads any existing PulseAudio modules and restarts PulseAudio to ensure a clean audio setup.
Load Configuration Variables: 
efines variables for sink names.
Load the Null Sink Module:
Creates a virtual sink named "loopback" using the ALSA source.
Load Echo Cancellation Module:
Loads the echo cancellation module to cancel echo from the loopback.
Load Ladspa Effects:
Loads Ladspa effects for declipping and pitch correction.
Prepare to Record:
Determines the length of the audio to be recorded and prepares for downloading a lyrics video if a URL is provided.
Start Recording:
Starts recording audio with applied effects using parec and sox.
Launch Lyrics Video:
Downloads and plays the lyrics video using mplayer.
Stop Recording:
Stops recording after the lyrics video is finished or interrupted.
Housekeeping:
Cleans up by terminating unnecessary processes.

Trigger Post Processing: Calls the betaKE.sh script for post-processing.

betaKE.sh ID_SEU_KARAOKE TITULO_DO_VIDEO_FINAL_Mp4:

This script performs post-processing on the recorded audio and video. Here’s an overview:

Clean Up:
Unloads modules and cleans up the audio setup left by betaREC.sh.
Check Parameters:
Checks if the required parameters are provided, which are the name of the playback without the WAV extension and the title in MP3 format.
Perform Post-Processing:
 Uses ffmpeg to apply various audio filters, including echo cancellation, autotune, volume normalization, and mixing. It also overlays visual effects on the video.
Play Processed Video:
Uses mplayer to play the processed video.

Requisitos de instalação

• yt-dlp – downloader of videos from YouTube and other sites
• sox – Swiss army knife of sound processing
• ffmpeg – Tools for transcoding, streaming and playing of multimedia files
• mplayer – movie player for Unix-like systems
• autotalent – pitch correction LADSPA plugin
• pulseaudio-utils – Command line tools for the PulseAudio sound server
• alsa-utils – Utilities for configuring and using ALSA
• Steve Harris LADSPA plugins

No Ubuntu instale esses pacotes e ele vai puxar as dependencias:

sudo apt install -y sox ffmpeg mplayer autotalent pulseaudio-utils alsa-utils swh-plugins yt-dlp;

• Se os arquivos de áudio de entrada tiverem diferentes frequências de amostragem, é uma boa prática convertê-los para a mesma frequência antes de misturá-los, a fim de evitar distorções e outros problemas.
• Você pode fazer isso usando o filtro aresample do FFmpeg
• Essas são as operações realizadas no comando ffmpeg para processar o áudio vocal e instrumental.
• Cada filtro desempenha um papel específico na manipulação do áudio para alcançar o resultado desejado.
• Os filtros na ordem errada podem prejudicar muito a qualidade do resultado!!!!!

Audio Processing Pipeline Documentation

This document describes an audio processing pipeline using ffmpeg to preprocess vocals with Autotalent, enhance the pitch-corrected vocals with effects, and masterize the audio for streaming, combining both playback and enhanced vocals.

The audio pipeline in the betaKE.sh script involves several steps of audio processing using ffmpeg. Let’s break down the pipeline in detail:

Input Sources:

Original Vocal Recording: This is the raw vocal recording obtained from the karaoke session.
Original Playback Audio: The original audio playback without any effects.
Lyrics Video Audio: The audio extracted from the lyrics video.
Filtering and Processing:

adeclip: This filter removes clipping distortion from the original vocal recording.
anlmdn: A noise gate filter that reduces low-level background noise.
ladspa=tap_autotalent: Applies autotune effect to the vocal recording for pitch correction. The parameters include the fundamental frequency, bandwidth, and formant shift.
compand: Compressor/expander filter that adjusts the dynamic range of the audio to make it sound more consistent.
firequalizer: Graphic equalizer filter that adjusts the frequency response of the audio.
aecho: Adds a simulated echo effect to the vocal recording.
treble: Adjusts the treble frequency range of the audio.
loudnorm: Loudness normalization filter that adjusts the volume level to a standardized level.
volume: Increases the overall volume of the audio.
aformat: Converts the audio format to a standardized format (floating-point PCM, 44100 Hz sample rate, stereo channels).
aresample: Resamples the audio to a standardized sample rate using the SoX resampler.
Mixing and Output:

Mixing: The processed vocal recording is mixed with the original playback audio using the amix filter.
Fading: The mixed audio is faded in over a duration of 2 seconds using the afade filter.
Visualization:

showcqt and avectorscope: Generate visualizations of the audio, including a continuous frequency transform (CQT) and an audio vectorscope.
Overlaying:

Overlaying Visual Effects: The visualizations are overlaid onto the video output.
Output Format:

The processed audio is encoded in AAC format with a bitrate of 320 kbps.
The output video format is MP4.
This pipeline applies a series of audio filters and effects to enhance the original vocal recording and mixes it with the original playback audio to create a final karaoke video with improved audio quality and visualizations.

These filters together process the vocal and playback audio, applying noise reduction, pitch correction, equalization, echo, and other effects, and then mix them together for the final output. Adjusting the parameters of these filters can result in different audio processing effects.

Páginas: 1 2