FaciLinux

Nello sviluppo di un bot di Telegram ho avuto la necessità di caricare le immagini gif animate dei radar meteo dell'ARPAV, che vengono aggiornate con una certa frequenza.

In una prima versione le immagini venivano scaricate in locale e poi caricate su Telegram.

Leggendo la documentazione delle API Telegram del metodo "sendDocument"

File to send. Pass a file_id as String to send a file that exists on the Telegram servers (recommended), pass an HTTP URL as a String for Telegram to get a file from the Internet, or upload a new one using multipart/form-data.

volevo velocizzare la risposta del bot alla richiesta del client sfruttando la possibilità di far eseguire ai server Telegram il download dell'immagine.

Il metodo funziona, ma mi sono scontrato con un problema: le immagini non erano aggiornate, ma si riferivano ad anni indietro.

Telegram risulta fare il caching degli URL che vengono inviati e non c'è modo automatico per scatenarne un aggiornamento.
Ciò è dovuto probabilmente alla funzonalità di "Link Preview" (quando viene scritto un URL in una chat Telegram genera una preview) e si ripercuote anche sull'invio di documenti e immagini.
Altri riferimenti a questo comportamento sono documentati qui e qui anche se non ho trovato una documentazione ufficiale.

Per aggirare il problema ho seguito una soluzioneproposta in una delle due discussioni:
generare un URL variabile nel tempo che venga poi rediretto all'URL dell'immagine.

Su un server http (ad es. example.com) viene creato un file rd.php

<?php
header("Location: http://original.url.com/image.jpg");
die();
?>

e una directory /get/ nella quale viene posizionato questo file .htaccess

RewriteEngine on
RewriteRule ^(.*)$ http://example.com/rd.php

In questo modo ogni URL del tipo http://example.com/get/qualsiasicosa
viene riscritto come http://example.com/rd.php
e quindi viene rediretto all'URL http://original.url.com/image.jpg dell'immagine che deve essere caricata.

Poichè qualsiasicosa deve variare nel tempo il candidato ideale è una qualche forma di timestamp.

Questa configurazione è stata fatta utilizzando il servizio di hosting gratuito Altervista.

Riprendiamo l'articolo "Scaricare un mp3 da un video di Youtube da linea di comando".
E se si volesse normalizzare il volume di un file audio scaricato da YouTube?
In realtà l'audio di YouTube viene già in qualche modo normalizzato e l'unica elaborazione con un certo senso sarebbe quella di alzarne il volume ossia una normalizzazione di picco.

Normalizzazione di un file audio

Il processo di normalizzazione dell'audio è l'applicazione di una quantità costante di guadagno a una registrazione audio per portare l'ampiezza a un livello target. Poiché la stessa quantità di guadagno viene applicata all'intera registrazione, il rapporto segnale-rumore e la dinamica relativa rimangono invariati.

Esistono due principali tipi di normalizzazione audio:

• peak normalization o normalizzazione del picco che regola la registrazione in base al livello di segnale più alto presente nella registrazione
• loudness normalization o normalizzazione del volume che regola la registrazione in base al volume percepito

Peak normalization

In questo tipo di normalizzazione il guadagno viene modificato per portare il più alto valore dei singoli campionamenti PCM o il picco del segnale analogico a un dato livello (solitamente 0 dBFS, il livello più alto consentito in un sistema digitale).

Poiché cerca solo il livello più alto, questo tipo di normalizzazione non tiene conto del volume apparente dell'audio.

Loudness normalization

Un altro tipo di normalizzazione si basa sulla misurazione del volume. Il guadagno viene modificato per portare l'ampiezza media a un livello target. Questa media può essere una semplice misurazione della potenza media (come il valore RMS) oppure può essere una misura del volume percepito dall'uomo (come l' EBU R128).

Normalizzazione a riga di comando

Per normalizzare un file audio a riga di comando in Linux possiamo usare ffmpeg-normalize

ffmpeg-normalize

La pagina web di riferimento è https://github.com/slhck/ffmpeg-normalize

Prerequisiti per l'installazione sono: - python 2.7 o 3 - ffmpeg v3.1 o successivi

Per installarlo utilizzare questo comando

pip3 install ffmpeg-normalize

Alcuni esempi

• normalizzare (EBU R128) un file mp3 (è necessario specificare encoder e output)
  ffmpeg-normalize input.mp3 -c:a libmp3lame -b:a 320k -o output.mp3
• normalizzare (peak normalization) un file mp3
  ffmpeg-normalize input.mp3 --normalization-type peak --target-level 0 -c:a libmp3lame -b:a 320k -o output.mp3 ffmpeg-normalize input.mp3 -nt peak -t 0 -c:a libmp3lame -b:a 320k -o output.mp3

Integrazione con youtube-dl

Per integrare la normalizzazione audio con youtube-dl si usa lo switch --exec

Per es. una normalizzazione EBU R128

youtube-dl -i --extract-audio --audio-format mp3 --audio-quality 0 https://www.youtube.com/watch?v=xymjDyGIvQ4 --exec 'ffmpeg-normalize {} -c:a libmp3lame -b:a 320k -o output.mp3 && rm {} && mv output.mp3 {}'

Per es. una normalizzazione peak

youtube-dl -i --extract-audio --audio-format mp3 --audio-quality 0 https://www.youtube.com/watch?v=xymjDyGIvQ4 --exec 'ffmpeg-normalize {} --normalization-type peak --target-level 0 -c:a libmp3lame -b:a 320k -o output.mp3 && rm {} && mv output.mp3 {}'

Come già detto l'audio di YouTube viene già normalizzato e una normalizzazione EBU R128 potrebbe risultare controproducente.

Esempio

Scarichiamo una traccia audio da YouTube e la rinominiamo orig.mp3

youtube-dl -i --extract-audio --audio-format mp3 --audio-quality 0 https://www.youtube.com/watch?v=xymjDyGIvQ4 --exec 'mv {} orig.mp3'

e analizziamone il volume

$ ffmpeg -i orig.mp3 -filter:a volumedetect -f null /dev/null

[Parsed_volumedetect_0 @ 0x55a943b5e2c0] n_samples: 20695734
[Parsed_volumedetect_0 @ 0x55a943b5e2c0] mean_volume: -15.7 dB
[Parsed_volumedetect_0 @ 0x55a943b5e2c0] max_volume: -3.0 dB
[Parsed_volumedetect_0 @ 0x55a943b5e2c0] histogram_2db: 1
[Parsed_volumedetect_0 @ 0x55a943b5e2c0] histogram_3db: 18
[Parsed_volumedetect_0 @ 0x55a943b5e2c0] histogram_4db: 1696
[Parsed_volumedetect_0 @ 0x55a943b5e2c0] histogram_5db: 76023

Ora applichiamo una normalizzazione EBU R128

ffmpeg-normalize orig.mp3 -c:a libmp3lame -b:a 320k -o ebur128.mp3

e poi una peak con volume target 0 db

ffmpeg-normalize orig.mp3 --normalization-type peak --target-level 0 -c:a libmp3lame -b:a 320k -o peak0.mp3

Ora analizziamo il volume dei due file normalizzati

$ ffmpeg -i ebur128.mp3 -filter:a volumedetect -f null /dev/null

[Parsed_volumedetect_0 @ 0x555d11c94780] n_samples: 20695734
[Parsed_volumedetect_0 @ 0x555d11c94780] mean_volume: -24.4 dB
[Parsed_volumedetect_0 @ 0x555d11c94780] max_volume: -10.1 dB
[Parsed_volumedetect_0 @ 0x555d11c94780] histogram_10db: 382
[Parsed_volumedetect_0 @ 0x555d11c94780] histogram_11db: 2813
[Parsed_volumedetect_0 @ 0x555d11c94780] histogram_12db: 6570
[Parsed_volumedetect_0 @ 0x555d11c94780] histogram_13db: 31148

$ ffmpeg -i peak0.mp3 -filter:a volumedetect -f null /dev/null

[Parsed_volumedetect_0 @ 0x5636f8793780] n_samples: 20695734
[Parsed_volumedetect_0 @ 0x5636f8793780] mean_volume: -12.7 dB
[Parsed_volumedetect_0 @ 0x5636f8793780] max_volume: -0.0 dB
[Parsed_volumedetect_0 @ 0x5636f8793780] histogram_0db: 16
[Parsed_volumedetect_0 @ 0x5636f8793780] histogram_1db: 1741
[Parsed_volumedetect_0 @ 0x5636f8793780] histogram_2db: 76022

Come si può vedere l'audio normalizzato EBU R128 risulta più basso di volume dell'originale

Risorse:
https://github.com/slhck/ffmpeg-normalize http://www.audiosonica.com/it/recensioni/post/16881/Loudness_e_sua_normalizzazione

Lo ammetto: (anche io) sono rimasto confuso dall'utilizzo del Tree View "Project". Ogni volta che finivo di inserire i progetti nel Tree View, me li ritrovavo poi spariti definitivamente una volta aperti con Atom file esterni ai progetti.

Il motivo di tale comportamento di Atom è spiegato in questo post "Why don’t my project folders stay open each time I start Atom?"

Much of the confusion has stemmed from the way the tree view appears to be a list of folders for projects. This is not its intended role; instead, it is a list of folders for the current project

ossia

Gran parte della confusione è derivata dal fatto che il Tree View sembra essere una lista di cartelle per progetti. Questo non è il suo ruolo inteso; invece, è un elenco di cartelle per il progetto corrente

Quindi non è una vista ad albero dei progetti, ma una vista ad albero delle directory del progetto corrente; eventualmente è possibile aprire uno dei progetti chiusi con File > Reopen Project".

Se si vuole invece avere a disposizione un gestore di progetti, come scritto nel post è possibile:

• organizzare a livello di filesystem le cartelle dei progetti (per progetti semplici)
• installare un community package per la gestione dei progetti

In questo ultimo caso i migliori pacchetti sono:

• project-manager (https://atom.io/packages/project-manager)
• project-plus (https://atom.io/packages/project-plus)