collapse

* Posts Recentes

Rede de comboios elétricos totalmente autónomos 10 ton em Rust em realtime. por blabla
[18 de Setembro de 2022, 18:44]


NiMH por 18650 por almamater
[18 de Setembro de 2022, 17:21]


How We Get Down to 0.2nm CPUs and GPUs - TechTechPotato por blabla
[18 de Setembro de 2022, 15:38]


Nova secção de Raspberry Pi Bare Metal em C e em Rust e Systems Programming por blabla
[04 de Setembro de 2022, 08:55]


The code for AGI will be simple - John Carmack and Lex Fridman por blabla
[29 de Agosto de 2022, 07:36]


Wavelets: a mathematical microscope por blabla
[28 de Agosto de 2022, 20:50]


Bom livro - Dive Into Systems por blabla
[28 de Agosto de 2022, 12:19]


graus negativos inclinação por josecarlos
[28 de Agosto de 2022, 11:31]


Super obsolescência super programada? por SerraCabo
[06 de Agosto de 2022, 11:36]


Motor de aspirador por dropes
[02 de Agosto de 2022, 22:18]

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

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

Offline blabla

  • Mini Robot
  • *
  • Mensagens: 245
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: 245
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 »