collapse

* Posts Recentes

Fiz um port dos Audio filters da WebAudio API por blabla
[Ontem às 12:22]


OpAmp Rail2Rail, 30V ... e mais umas coisinhas por Njay
[04 de Dezembro de 2021, 17:31]


Por que nunca se deve confiar no que diz o cliente por dropes
[03 de Dezembro de 2021, 14:17]


Loja a EVITAR por dropes
[27 de Novembro de 2021, 19:35]


Projecto LED fundem por pouco funcionamento? por filjoa
[24 de Novembro de 2021, 10:45]


Um recurso muito completo com implementações de algoritmos. por blabla
[23 de Novembro de 2021, 12:04]


Como resolver "uhmmm" 50Hz Colunas de PC por dropes
[22 de Novembro de 2021, 14:12]


Software TV sala espera + Publicidades por m90mine
[19 de Novembro de 2021, 14:32]


Stenography - Using programming to save ancient writing method por blabla
[18 de Novembro de 2021, 13:55]


Identificador Via Verde por almamater
[15 de Novembro de 2021, 16:20]

Autor Tópico: Uma boa lib de processamento de áudio com efeitos para C, C++ ou Rust.  (Lida 298 vezes)

0 Membros e 1 Visitante estão a ver este tópico.

Offline blabla

  • Mini Robot
  • *
  • Mensagens: 81
Boa tarde a todos,

recentemente pensei em fazer uns programetas na área de áudio que utilizassem redes neuronais, estava a pensar usar o PyTorch, mas como desta vez não queria usar Python, estava a pensar fazer em Rust, usaria os bindings de Rust para as libs de PyTorch escritas em C++ que estão por de baixo do front-end em Python.

tch
Rust wrappers for the PyTorch C++ api (libtorch).
https://crates.io/crates/tch

Exemplos
https://github.com/LaurentMazare/tch-rs/tree/main/examples

Mas depois gostaria de usar em Rust, as libs de audio do PyTorch Audio, contudo essas já não estão feitas de raiz em C ou C++ no PyTorch, mas sim como libs de Python que mapeiam a libSOX do grande programa  SoX - Sound eXchange.

Em Python também existe uma outra boa lib de processamento de áudio que é a libROSA, mas essa também é uma lib em C/C++ feita exclusivamente para Python, com os objetos de Python.

https://librosa.org/

Mas voltando ao SoX …. eu já conheço este programa já há muitos anos, mas nunca o tinha visto com  olhos de ver, por exemplo, os manuais do programa e todas os inúmeros features que ele tem. Podem ver aqui uma lista dos seus features:

http://sox.sourceforge.net/Docs/Features

O SoX faz muita coisa num único programa e numa única lib a libSOX! Sendo que esta tem uma interface simples com poucas funções e estruturas de C. Pode-se executar efeitos e existe conceito de chain (cadeia ou sequência) de efeitos, em que se coloca um efeito ou filtro atrás do outro num caminho em que o audio percorre, entra de um lado e sai do outro. Podem também haver “mixagens” entre vários ficheiros de audio, com múltiplos canais.

O site do SoX é este:
http://sox.sourceforge.net/

O manual do SOX pode ser visto aqui:
http://sox.sourceforge.net/sox.html

O manual da libSOX em C pode ser visto aqui:
http://sox.sourceforge.net/libsox.html

O ficheiro .h da libSOX pode ser visto aqui e é o sox.h, comum a todo o SOX:
https://sourceforge.net/p/sox/code/ci/master/tree/src/sox.h

Os bindings para Rust da libSOX são gerados automaticamente neste crate (package):

libsox-sys
https://crates.io/crates/libsox-sys

Para usarem esta lib em Rust tem de usar funções do tipo unsafe e um bom exemplo de como elas se usam neste contexto, incluindo a aplicação de efeitos, pode ser visto aqui:

https://github.com/vtavernier/libsox-sys/blob/master/examples/example1.rs

Todos os efeitos estão listados aqui:
https://sourceforge.net/p/sox/code/ci/master/tree/src/effects.h

Existem 7 exemplos da utilização da libSOX em C e que podem ser usados como ponto de partida para se perceber como usar os bindings de Rust para a libSOX, eles são:

https://sourceforge.net/p/sox/code/ci/master/tree/src/example0.c
https://sourceforge.net/p/sox/code/ci/master/tree/src/example1.c
https://sourceforge.net/p/sox/code/ci/master/tree/src/example2.c
https://sourceforge.net/p/sox/code/ci/master/tree/src/example3.c
https://sourceforge.net/p/sox/code/ci/master/tree/src/example4.c
https://sourceforge.net/p/sox/code/ci/master/tree/src/example5.c
https://sourceforge.net/p/sox/code/ci/master/tree/src/example6.c

Um bom exercício seria o de re-implementar os 6 exemplos que faltam em Rust.

A documentação dos bindings da lib podem ser vistos aqui (mas devem ser vistos à luz do manual da libSOX que coloquei em cima):

https://vtavernier.github.io/libsox-sys/libsox_sys/index.html

Existe ainda uma lib em de Rust especifica para a Resample de buffer com a libSOX Resampler Library:

libsoxr
Wrapper for libsoxr (resampling library for sounds)
https://crates.io/crates/libsoxr

Em Rust existe ainda uma outra lib de processamento de áudio, mas está mais focada no low level que é a dasp:

dasp
A crate providing the fundamentals for working with audio PCM DSP.
https://crates.io/crates/dasp

Cumprimentos,
João
« Última modificação: 01 de Novembro de 2021, 17:10 por blabla »

Offline blabla

  • Mini Robot
  • *
  • Mensagens: 81
Re: Uma boa lib de processamento de áudio com efeitos para C, C++ ou Rust.
« Responder #1 em: 02 de Novembro de 2021, 18:36 »
Boa tarde,

hoje tentei instalar a a libsox-sys para o Rust em Linux Ubuntu 20.04 e estava a dar-me uns erros de compilação, como outros podem tentar fazer o mesmo, deixo aqui uma pequena solução para conseguirem compilar o exemplo que está na diretoria

https://github.com/vtavernier/libsox-sys/tree/master/examples   

Primeiro vão para uma diretoria onde queiram colocar o vosso projeto e depois criem um projeto vosso para testar a libsox eu chamei a esse projecto libsox_test:

> cargo new libsox_test
> cd libsox_test

Adicionem ao ficheiro .toml as seguintes dependências:

[dependencies]
libc = "0.2.106"
libsox-sys = "0.1.1"


Depois copiem o conteúdo ficheiro:

https://github.com/vtavernier/libsox-sys/tree/master/examples/example1.rs

para o /src/main.rs

depois tem de instalar os packages de dependências no Ubuntu/Debian:

#
Instalar o sox.

> sudo apt-get update
> sudo apt-get install sox

#
Instalar a libsox-dev.

> sudo apt-get install libsox-dev

# 3º
Se não tem o clang instalado, o compilador de Rust não consegue compilar a lib.rs . Para corrigir esse erro, instalem o clang via o pacote libclang.

Debian/Ubuntu:

> sudo apt-get install libclang-dev

Note: Para encontrar a solução para este segundo problema eu segui o tutorial:
          Fixing Rust compilation issues caused by missing packages, part 2
          https://www.unadulterated-faff.com/articles/2020/02/04/fixing-rust-compilation-issues-caused-by-missing-packages-part-2.html

Depois já podem compilar fazendo:

> cargo build       ou      cargo build --release

Para executar arranjem um WAV por exemplo 1.wav e façam:

> cargo run 1.wav out.wav

Ele vai gerar o ficheiro de output mas não vai notar-se diferença nenhuma, por isso alterem a linha 103 do main.rs

de:
let vol = [b"3dB\0".as_ptr() as *mut i8];

para:
let vol = [b"-6dB\0".as_ptr() as *mut i8];

Executem outra vez:
> cargo run 1.wav out.wav

E agora já vão ouvir o segundo WAV com uma amplitude de áudio mais baixa do que o primeiro.

------------------------

Gostava só de deixar a seguinte nota:

O código Rust que tem de ser usado para utilizar esta libSOX de C é Rust Unsafe e podem comparar dos exemplos que eu listei no post anterior, o exemplo1.c e o exemplo1.rs .

Se os virem com atenção vão ver algumas coisas de diferente em C e em Rust para chamar a mesma lib, deixo aqui um exemplo de 3 coisas:

Em C onde está:

/* input and output files */
static sox_format_t * in, * out;

Em Rust unsafe fica:

static mut IN_FILE: *mut sox_format_t = ptr::null_mut();
static mut OUT_FILE: *mut sox_format_t = ptr::null_mut();


Em C onde está:

char * vol[] = {"3dB"};

Em Rust unsafe fica:

let vol = [b"3dB\0".as_ptr() as *mut i8];


Em C onde está:

assert(sox_add_effect(chain, e, &in->signal, &in->signal) == SOX_SUCCESS);

Em Rust unsafe fica:

assert!(sox_add_effect(chain, e, &mut (*IN_FILE).signal, &(*IN_FILE).signal) == sox_error_t_SOX_SUCCESS);

Volto a dizer isto é código Rust Unsafe, não é código em Rust normal, e é código para poder interligar diretamente com bindings feitos em C. Código Rust normal é muito mais limpo.

Só necessitam de código Rust Unsafe para fazer as chamadas, podem criar uma camada de abstração mais elevada que já seja Rust normal, sem ser unsafe.

Cumprimentos,
João
« Última modificação: 02 de Novembro de 2021, 18:38 por blabla »