Gravador de Áudio com Python – Como criar do Zero!

Aprenda criar um gravador de áudio com Python! Crie do zero um código capaz de gravar áudio do seu computador usando o próprio Python.

Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!

Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:

Gravador de Áudio com Python

Nesta aula, você aprenderá a criar um gravador de áudio com Python a partir do zero!

Através deste projeto, você terá um código em Python capaz de capturar e gravar o áudio do seu computador, deixando o arquivo salvo para que você possa utilizá-lo posteriormente como preferir.

Para isso, utilizaremos as bibliotecas PyAudio e Wave. Vou explicar detalhadamente cada etapa do código e a configuração dessas bibliotecas. Portanto, faça o download do material disponível e vamos começar!

Instalação e Importação das Bibliotecas PyAudio e Wave

Para começarmos a construção do nosso gravador de áudio com Python, o primeiro passo será abrir um arquivo Python no editor de código de sua preferência. Eu utilizarei o VS Code. Em seguida, faça a instalação das bibliotecas necessárias.

Para instalá-las, basta executar o comando abaixo no terminal do seu editor de código:

pip install pyaudio wave

Como vai ser feita a gravação de áudio com Python?

O nosso gravador de áudio com Python funcionará da seguinte forma:

Vamos criar uma stream de áudio, que é uma variável responsável por receber as informações do microfone do computador. Essas informações serão fragmentos de dados que serão armazenados em uma lista Python. Ao final, essas listas serão unidas em um único arquivo de áudio.

Construção do Código do Gravador de Áudio com Python e Explicações

O primeiro passo para iniciar o nosso código do gravador de áudio com Python é importar as bibliotecas que instalamos anteriormente e que serão necessárias para o seu funcionamento:

import  pyaudio
import wave

Em seguida, criamos uma instância da classe PyAudio da biblioteca PyAudio. Essa instância permite a captura de informações do nosso microfone:

audio = pyaudio.PyAudio()

Agora, vamos construir o nosso objeto stream, que é um objeto de fluxo de áudio, responsável por coletar as informações do áudio. Para isso, inicializamos uma instância da classe audio usando o método open():

stream = audio.open()

Para configurar esse objeto, precisamos definir várias configurações e parâmetros que determinarão as características do nosso áudio. Esses parâmetros incluem:

input = True: Isso indica que o fluxo é para a entrada de áudio, ou seja, estamos capturando áudio do microfone.

format = pyaudio.paInt16: Define o formato do áudio como sendo de 16 bits. Isso determina a precisão da amplitude das amostras de áudio. Proporcionando diferentes níveis de volume e qualidade.

Quanto maior esse valor, maior será a qualidade do áudio, mas também resultará em um tamanho de arquivo maior. Por outro lado, um valor menor proporcionará uma qualidade inferior e um tamanho de arquivo menor.

channels = 1: Configura a quantidade de canais que nosso áudio terá. Nesse caso, todo o áudio será gravado em um único canal, o que é conhecido como áudio mono. Em um áudio estéreo, teríamos dois canais: um para o áudio da esquerda e outro para o áudio da direita.

rate = 44000: A taxa de amostragem é o número de amostras de áudio coletadas por segundo, medida em Hertz (Hz). Quanto maior essa taxa, mais amostras são coletadas, resultando em um áudio mais preciso e de melhor qualidade.

frames_per_buffer = 1024: Especifica o tamanho do buffer de captura do áudio. Um “buffer” é uma área temporária da memória usada para armazenar uma quantidade limitada de dados de áudio antes que eles sejam processados ou escritos em outro lugar.

Esse parâmetro define o tamanho desse buffer em termos do número de quadros (frames) de áudio que ele pode conter. Ou seja, ele define o número de amostras de áudio que são lidas a cada iteração, no nosso caso, 1024 quadros de áudio.

Ao passar cada um desses parâmetros, nosso objeto de áudio ficará da seguinte forma:

stream = audio.open(
     input = True,
     format = pyaudio.paInt16,
     channels = 1,
     rate = 44000,
     frames_per_buffer = 1024,
)

Como mencionado anteriormente, nosso áudio será armazenado em blocos de 1024 quadros. Portanto, precisamos criar uma lista vazia chamada frames para armazenar os blocos de áudio capturados:

frames = []

Com o nosso receptor de áudio criado e configurado, precisamos executar a gravação em si. Para isso, vamos criar um loop infinito que irá ouvir esse áudio e adicionar cada bloco a nossa lista frames. Vamos definir esse loop infinito dentro de um bloco try:

try:
    while True:
        bloco = stream.read(1024)
        frames.append(bloco)
except KeyboardInterrupt:
    pass

Dessa forma, nosso código começará a capturar o áudio, lendo um bloco de áudio com 1024 amostras recebidas do objeto stream e armazenando esse bloco na variável bloco. Em seguida, esse bloco é adicionado à lista frames.

A captura do áudio será interrompida manualmente pelo teclado, no caso do VS Code, poderemos parar o código quando pressionarmos Ctrl + C.

Quando essa interrupção acontece, ela gera uma exceção que será tratada dentro do bloco except KeyboardInterrupt. Quando essa exceção é gerada, o loop é encerrado, finalizando a gravação.

Após a captura do nosso áudio ser concluída, precisamos fechar o fluxo de áudio (stream) que havíamos inicializado e também encerrar a instância audio que configuramos anteriormente. Fazemos isso com o seguinte código:

stream.start_stream()
stream.close()
audio.terminate()

Para finalizar, vamos criar e configurar nosso arquivo WAV onde iremos salvar o áudio gravado. A variável arquivo_final representará o nosso arquivo WAV e receberá a função wave.open() para abrir e criar o arquivo:

arquivo_final = wave.open("gravacao.wav", "wb")

Dentro da função open(), estamos passando o nome do nosso arquivo e a extensão (gravacao.wav) e definindo o modo de escrita como wb (write binary), que é o modo de abertura para escrita de dados binários, a forma como os dados de áudio são tratados.

Feito isso, vamos configurar o arquivo final com as configurações de áudio que definimos para o nosso fluxo de áudio:

arquivo_final = wave.open("gravacao.wav", "wb")
arquivo_final.setnchannels(1)
arquivo_final.setframerate(44000)
arquivo_final.setsampwidth(audio.get_sample_size(pyaudio.paInt16))

Configuramos o arquivo para ser mono (um canal), com uma taxa de amostragem de 44.000 amostras por segundo e uma largura de amostra de 16 bits, correspondente ao formato de áudio que usamos para a gravação.

Finalmente, podemos escrever os dados de áudio gravados no arquivo WAV, salvando-o em nosso computador:

arquivo_final.writeframes(b"".join(frames))
arquivo_final.close()

Nesse processo, para salvar o nosso arquivo, pegamos todos os dados gravados na nossa lista frames e os concatenamos usando a função join. Para garantir que esses dados sejam escritos no formato de bytes, adicionamos a letra b antes do join.

Nosso código final ficará da seguinte forma:

import pyaudio
import wave

audio = pyaudio.PyAudio()

stream = audio.open(
    input=True,
    format=pyaudio.paInt16,
    channels=1,
    rate=44000,
    frames_per_buffer=1024,
)

frames = []

try:
    while True:
        bloco = stream.read(1024)
        frames.append(bloco)
except KeyboardInterrupt:
    pass

stream.start_stream()
stream.close()
audio.terminate()

arquivo_final = wave.open("gravacao.wav", "wb")
arquivo_final.setnchannels(1)
arquivo_final.setframerate(44000)
arquivo_final.setsampwidth(audio.get_sample_size(pyaudio.paInt16))
arquivo_final.writeframes(b"".join(frames))
arquivo_final.close()

Assim, concluímos a criação do nosso gravador de áudio com Python. Ao executar esse código, ele começará a gravar o áudio do seu microfone até que você o interrompa manualmente e depois armazenará o arquivo gravado no seu computador.

Conclusão – Gravador de Áudio com Python

Na aula de hoje, passei a você o passo a passo de como criar um gravador de áudio com Python, explicando detalhadamente cada etapa do nosso código.

Agora, você tem a capacidade de criar um código padrão que pode ser usado sempre que desejar gravar áudio em seu computador, fazendo apenas as adaptações e configurações do áudio de acordo com suas necessidades.

Além disso, é possível expandir ainda mais esse gravador, desenvolvendo, por exemplo, uma interface para ele, uma janela que tornará seu gravador mais atraente e intuitivo, com botões para iniciar e parar a gravação.

Se você deseja aprender mais maneiras de fazer o Python reconhecer o áudio do seu computador, temos duas aulas bastante interessantes para você acompanhar:

• Como transcrever áudio com Python
• Reconhecimento de fala com Python

Hashtag Treinamentos

Para acessar outras publicações de Python, clique aqui!

Diego Monutti

Expert em conteúdos da Hashtag Treinamentos. Auxilia na criação de conteúdos de variados temas voltados para aqueles que acompanham nossos canais.