FaciLinux

Guide Facili per Linux

Ultimamente mi è capitato di dover lavorare con file di testo generati da script powershell, in particolare dall'utility Out-File.

Il problema che ho trovato è stato nell'encoding del file generato da Powershell, che nel mio caso era UTF16-Little Endian, un encoding che mal si sposa con le utility di parsing dei file della bash.

Per scoprire con quale encoding ci stiamo confrontando, ci viene in aiuto il comando file; infatti Out-File supporta parecchi encoding in output (https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/out-file?view=powershell-6#parameters), quindi nel caso questa guida è da aggiustare con l'encoding che fa al caso vostro.

Il primo passo, come detto, è scoprire con quale encoding si ha a che fare:

[user@pc ~]$ file -i output_powershell.txt 
output_powershell.txt: text/plain; charset=utf-16le

La desiderata è di ottenere un file in UTF8, con i carriage return di linux, ed ecco come fare:

iconv -f UTF-16LE -t UTF8 output_powershell.txt | dos2unix > converted_output.txt

In caso manchi l'utiliy dos2unix è possibile installarla con il proprio gestore di pacchetti; per Arch ad esempio il comando è

sudo pacman -Su dos2unix

Il nostro file convertito è ora un ottimo candidato per passare sotto altri strumenti di parsing.

Buon lavoro!

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

Lavorando a riga di comando su una piattaforma Linux, prima o poi, abbiamo bisogno di un aiuto sui comandi della shell. Anche se sono disponibili i comandi di sistema man e whatis, a volte l'aiuto del primo è troppo descrittivo mentre il secondo lo è poco.

Ci sono poi applicazioni di terze parti come cheat, che mostra l'aiuto sul comando della shell anche quando il computer non è connesso a Internet, ma solo su comandi predefiniti.

E' possibile creare un nuovo comando attraverso uno script scritto da Jackson (https://www.mankier.com/explain), che è in grado di spiegare i comandi di shell all'interno della shell bash in modo molto efficace e indovinando quale parte della pagina di aiuto sia la migliore da visualizzare. Il comando si chiama explain.

L'unico requisito è il pacchetto curl. Se non è già installato sul sistema in uso, installarlo con i comandi:

apt-get install curl

Installazione del comando explain in Linux

Bisogna inserire il codice sottostante come nel file ~/.bashrc dell'utente.

# Add this to ~/.bash_profile or ~/.bashrc
explain () {
  if [ "$#" -eq 0 ]; then
    while read  -p "Command: " cmd; do
      curl -Gs "https://www.mankier.com/api/v2/explain/?cols="$(tput cols) --data-urlencode "q=$cmd"
    done
    echo "Bye!"
  elif [ "$#" -eq 1 ]; then
    curl -Gs "https://www.mankier.com/api/v2/explain/?cols="$(tput cols) --data-urlencode "q=$1"
  else
    echo "Usage"
    echo "explain                  interactive mode."
    echo "explain 'cmd -o | ...'   one quoted command to explain it."
  fi
}

# Update 26-03-2015. If using this command gives no output, see if running a simple fetch causes this error:
# $ curl https://www.mankier.com
# curl: (35) Cannot communicate securely with peer: no common encryption algorithm(s).
# If so, try specifying a cipher in the curl commands: curl --ciphers ecdhe_ecdsa_aes_128_sha

https://www.mankier.com/blog/explaining-shell-commands-in-the-shell.html

Dopo aver inserito il codice e averlo salvato, è necessario disconnettersi dalla sessione corrente e accedere nuovamente per rendere effettive le modifiche.

Utilizzo del comando explain

Proviamo alcuni esempi:

  1. Cosa fa 'du -h': explain 'du -h'

  2. Cosa fa 'tar -zxvf': explain 'tar -zxvf'

  3. Confrontare due comandi
    E' possibile andare in modalità interattiva semplicemente digitando il comando explain e poi digitare i comandi uno dopo l'altro per vedere cosa fanno.
    Per uscire dalla modalità interattiva, è sufficiente fare Ctrl + c.

  4. E' possibile chiedere cosa fanno più comandi in pipeline: explain 'ls -l | grep -i Desktop'

Dokuwiki è un potente wiki opensource che permette di editare, far versioning di documenti e caricare file e immagini, anch'essi sottoposti a controllo di versione.

Il controllo di versione funziona in modo trasparente se si utilizza l'interfaccia web di dokuwiki, ma supponiamo di avere dei file che vengono generati sul server che ospita la vostra istanza dokuwiki, e supponiamo di volerli rendere disponibili come media all'interno di dokuwiki stesso, con il controllo di versione.

Dokuwiki non offre nessuno strumento nativo per questo tipo di esigenza ma, con un po' di reverse engineering di come funziona il sistema di versioning di dokuwiki è possibile realizzare tale istanza, ovvero copiare localmente un file all'interno della struttura media di dokuwiki, mantenendone il versioning (potendo quindi ripristinare versioni precedenti, qualora lo si rendesse necessario).

Prima di entrare nella modalità operativa occorre spiegare un attimo come funziona dokuwiki e il suo sistema di versioning. Dokuwiki è un sistema che funziona senza database, quindi tutta la logica di funzionamento è presente all'interno di directory e files nella struttura dell'istanza di dokuwiki.

Supponiamo di voler mantenere aggiornato, con controllo di versione, il file logs.zip creato da uno script sul server stesso che monta l'istanza di dokuwiki. Supponiamo di mantenere il file logs.zip all'interno del contenitore generale media.

Se si fa l'upload da interfaccia web del file logs.zip, quello che avviene a livello di filesystem è che il file viene salvato nella directory <path_dokuwiki>/data/media . Se il file viene sostituito da una versione più recente, il media manager compie queste azioni:

  1. Calcola la data di ultima modifica in timestamp unix del file logs.zip originale
  2. Sposta il file logs.zip originale nella directory <path_dokuwiki>/data/media_attic e lo rinomina come logs.<unix_timestamp_ultima_modifica>.zip
  3. Aggiunge al file <path_dokuwiki>/data/media_meta/logs.zip.changes una riga, la cui sintassi viene descritta più avanti, che mantiene le informazioni per il versioning
  4. Copia il nuovo file logs.zip in <path_dokuwiki>/data/media

Volendo fare "l'upload" del file logs.zip dall'interno del server stesso occorre quindi simulare le operazioni svolte dal media manager di dokuwiki.

La sintassi dei file con estensione .changes, che sono responsabili del mantenimento di versione, è la seguente; per ogni nuova versione del file caricata viene aggiunta una riga contenente le seguenti informazioni, separate da tabulazione:

  1. tempo di ultima modifica in unix timestamp del nuovo file
  2. ip di origine
  3. Flag di creazione/modifica
  4. path del file in notazione namespace
  5. utente che ha fatto la modifica
  6. riga "creata" se creazione
  7. dimensione del file in byte

Usando uno script bash è possibile eseguire tutte le operazioni e i calcoli necessari, in particolare:

  1. tempo di ultima modifica in unix timestamp del nuovo file stat -c %Y
  2. ip di origine 127.0.0.1
  3. Flag di creazione/modifica C oppure E
  4. path del file in notazione namespace logs.zip
  5. utente che ha fatto la modifica (il proprio utente dokuwiki va bene)
  6. riga "creata" se creazione
  7. dimensione del file in byte ls -l file| awk '{print $5}'

Un ipotetico script in bash, quindi, conterrebbe le seguenti righe:

fileupd="<path>/logs.zip"
lastmod=$(stat -c %Y $fileupd)
fileupdsize=$(ls -l $fileupd| awk '{print $5}'
echo "$lastmod    127.0.0.1    E    logs.zip    mydoku-user        $fileupdsize >> <path_dokuwiki>/data/media_meta/logs.zip

Nello stesso script dovrebbe comparire anche la linea relativa allo spostamento e alla rinomina della vecchia versione del file logs.zip all'interno della directory <path_dokuwiki>/data/media_attic:

mv <path_dokuwiki>/media/logs.zip <path_dokuwiki>/media_attic/logs.$(stat -c %Y <path_dokuwiki>/media/logs.zip).zip

Infine, resta da copiare il nuovo file logs.zip all'interno della directory media e sistemarne i permessi perché sia leggibile all'utente che esegue l'istanza web (per Debian/Ubuntu, ad esempio, è l'utente www-data

mv $fileupd <path_dokuwiki>/media/
chown www-data:www-data <path_dokuwiki>/media/logs.zip

Per rendere il tutto automatico è possibile sfruttare naturalmente cron/anacron, così da far eseguire lo script senza necessità di interazione.

Sfruttando il software illustrato nell'articolo "Scaricare un video di Youtube da linea di comando", è possibile anche ottenere un file audio da un video o una playlist di Youtube.

Il processo è composto da due passi principali:

  1. viene scaricato il media nel formato originario (.webm)
  2. il media viene convertito nel formato desiderato (.mp3)

Per il passo di conversione il software youtube-dl si appoggia a:

  • avconv
  • ffmpeg (consigliato)

Andiamo quindi ad installare il software ffmpeg con il comando

sudo apt-get update
sudo apt-get install ffmpeg
ffmpeg -version

Per convertire in un file mp3 un video di Youtube possiamo utilizzare il comando

youtube-dl -i --extract-audio --audio-format mp3 --audio-quality 0 https://www.youtube.com/watch?v=xymjDyGIvQ4

dove

-i - ignora gli errori
--extract-audio - estrae la traccia audio
--audio-format mp3 - converte l'audio in formato mp3
--audio-quality 0 - imposta la qualità audio migliore

Se vogliamo aggiungere i tag ID3 partendo dai metadati del video di Youtube basta aggiungere lo switch --add-metadata

youtube-dl -i --extract-audio --audio-format mp3 --audio-quality 0 --add-metadata https://www.youtube.com/watch?v=xymjDyGIvQ4

Teamviewer© è un software per il controllo remoto di una postazione; viene distribuito per tutti i maggiori sistemi operativi, Linux incluso. Se avete installato il software completo, pacchettizzato in formato deb o rpm, viene anche aggiunto un canale ai vostri repository per l'aggiornamento del software, ma soprattutto viene aggiunto un demone, teamviewerd, che parte all'avvio del computer e resta in attesa di connessioni. Il demone è necessario anche se usiamo la nostra postazione per controllarne un'altra, ma ha naturalmente la doppia funzione; quando si installa Teamviewer anche la nostra macchina diventa potenzialmente controllabile da remoto. Certo, è necessario avere l'accoppiata di codice id e password, ma se non vi piace l'idea di avere un demone sempre in ascolto per una connessione remota sulla vostra postazione, ecco come fare per avviare Teamviewer, demone incluso, solo quando è strettamente necessario.

Innanzitutto occorre creare uno script wrapper, semplicemente uno script bash che si occupa di:

  • Avviare il demone (chiedendo delle credenziali amministrative)
  • Avviare l'interfaccia di Teamviewer
  • Alla chiusura di Teamviewer fermare il demone

Prendete lo script bash che trovate qui sotto e salvatelo come teamviewer-wrapper all'interno di una directory compresa nel vostro PATH di ricerca degli eseguibili (generalmente $HOME/bin può essere una buona scelta se siete gli unici utilizzatori del pc):

#!/bin/bash
#A wrapper for teamviewer
#Runs teamviewer daemon only when needed

#Set teamviewer path
teamv_path="/opt/teamviewer/tv_bin/"

#check path existence
if [ ! -d $teamv_path ]; then
    zenity --error --text "Errore.\nIl percorso $teamv_path non esiste."
    exit 1
else
    pid_daemon=$(pidof teamviewerd)
    if [ ! $pid_daemon == '' ]; then
        zenity --warning --text "Attenzione, il demone di teamviewer era già in esecuzione.\nPer disabilitarne l'avvio automatico usa il comando\n\nsudo systemctl disable teamviewerd\n\nda terminale."
    else
        pkexec /opt/teamviewer/tv_bin/teamviewerd -d
        pid_daemon=$(pidof teamviewerd)
    fi
    if [ $pid_daemon -gt 1 ]; then
        /opt/teamviewer/tv_bin/TeamViewer
        pkexec kill -9 $pid_daemon
        pid_daemon=$(pidof teamviewerd)
        if [ ! $pid_daemon == '' ]; then
            zenity --warning --text "Attenzione, il demone di teamviewer sembra ancora in esecuzione"
        fi
    fi
fi

A questo punto rendiamo lo script eseguibile; apriamo una finestra di terminale e digitiamo:

chmod +x $HOME/bin/teamviewer-wrapper

Ora occorre fermare e disabilitare il demone teamviewerd, i comandi da eseguire da terminale sono:

sudo systemctl disable teamviewerd
sudo systemctl stop teamviewerd

Ora potete lanciare il comando teamviewer-wrapper dal terminale; se volete integrarlo nel menu del vostro desktop, potete copiare il contenuto riportato qui sotto all'interno della directory $HOME/.local/share/applications, salvando il file con il nome com.teamviewer.TeamViewer.desktop

#!/usr/bin/env xdg-open
[Desktop Entry]
Version=1.0
Encoding=UTF-8
Type=Application
Categories=Network;

Name=TeamViewer 13
Comment=Remote control and meeting solution.
Exec=env teamviewer-wrapper

Icon=TeamViewer
Terminal=false

Aggiornamento di Teamviewer

Ogni volta che il pacchetto Teamviewer viene aggiornato, il demone teamviewerd viene riabilitato e fatto partire in modo silente, quindi dopo l'aggiornamento occorre ricordarsi di dare questi due comandi, per fermare e disabilitare nuovamente l'avvio al boot del demone:

sudo systemctl disable teamviewerd
sudo systemctl stop teamviewerd

Googler è un curioso strumento a linea di comando che permette di cercare risultati su Google (Web o News) direttamente dal terminale. È possibile scorrere tra i risultati con i tasti freccia della tastiera; ogni link è numerato sequenzialmente e per aprire il link che ci interessa nel browser predefinito basta digitare il numero corrispondente.

Per installare googler su Debian/Ubuntu basta digitare da terminale il comando:

sudo apt-get install googler

Per cercare il terminae "Italia" nel Web con googler basta un semplice:

googler Italia

Il risultato sarà qualcosa del genere: googler-italia

Per ricercare nelle news occorre aggiungere il flag -N, quindi per cercare le ultime notizie con la parola chiave Italia il comando sarà:

googler -N italia

Il risultato del comando sarà qualcosa di simile: googler-news-italia

Googler ha anche molte opzioni per un uso avanzato dello strumento; se siete curiosi vi consiglio di leggere la pagina di manuale, disponibile naturalmente con il comando:

man googler

Può capitare, mentre si lavora all'interno di una finestra di terminale, di voler/dover aprire un file - magari contenuto proprio nella directory su cui si sta lavorando - con un'applicazione grafica.

Ad esempio di potrebbe avere l'esigenza di aprire un file immagine o un foglio di calcolo o un documento scritto con libreoffice. Per fortuna esiste un unico comando che ci aiuta ad aprire qualsiasi file con l'applicazione predefinita. Il comando si chiama xdg-open e si invoca semplicemente aggiungendo il nome del file che si vuole aprire. Per aprire, ad esempio, il file spreadsheet.xls, basta dare il comando:

xdg-open spreadsheet.xls

Xdg-open si occuperà di invocare il programma predefinito per i file excel (probabilmente Libreoffice). Se si vuole mantenere la possibilità di digitare nuovi comandi mentre l'applicazione grafica lanciata da xdg-open è attiva, basta far seguire al comando l'and commerciale (&), così il comando continua in background e lascia utilizzabile la linea di comando. Per aprire il file pdf esempio.pdf in background con l'applicazione predefinita il comando sarà quindi:

xdg-open esempio.pdf &

Può alle volte essere necessario (o comodo) scaricare in locale un video pubblicato su youtube. Esistono plugin per i maggiori browser che permettono di eseguire questa azione, o anche applicazioni grafiche; è però possibile eseguire facilmente questo compito anche da una finestra di terminale, utilizzando il software youtube-dl. Tale software è spesso già disponibile pacchettizzato nei repository ufficiali della propria distribuzione, quindi, usando ad esempio un pc con Debian o Ubuntu, per l'installazione basta aprire un terminale e digitare:

sudo apt-get install youtube-dl

A volte però il programma non è disponibile nei respository, oppure quello pacchettizzato è una versione obsoleta e non più funzionante; la soluzione consiste allora nel recarsi sul sito del progetto e scaricare l'ultima release, ecco come fare:

  • Puntare un browser all'indirizzo https://rg3.github.io/youtube-dl/
  • Cliccare sul pulsante Download
  • Seguire le istruzioni fornite per ottenere il software

Youtuble-dl offre moltissime opzioni per un utilizzo avanzato (compreso, ad esempio, il download di intere playlist), tutta la documentazione aggiornata è disponibile sul sito del progetto, a questo indirizzo: https://github.com/rg3/youtube-dl/blob/master/README.md#readme Per un utilizzo "base" segnalo che basta invocare il comando seguito dall'URL del video youtube che si vuole scaricare perché youtube-dl si occupi di scaricare tale video con il formato predefinito. Supponiamo di voler scaricare questo video

della Linux Foundation, il comando da digitare a terminale sarà semplicemente:

youtube-dl https://www.youtube.com/watch?v=11VGDAOVEag

Per conoscere i formati in cui un video è disponibile occorre aggiungere il flag -F:

youtube-dl -F https://www.youtube.com/watch?v=11VGDAOVEag
[youtube] 11VGDAOVEag: Downloading webpage
[youtube] 11VGDAOVEag: Downloading video info webpage
[info] Available formats for 11VGDAOVEag:
format code  extension  resolution note
249          webm       audio only DASH audio   50k , opus @ 50k, 626.23KiB
250          webm       audio only DASH audio   66k , opus @ 70k, 833.89KiB
140          m4a        audio only DASH audio  129k , m4a_dash container, mp4a.40.2@128k, 1.68MiB
251          webm       audio only DASH audio  134k , opus @160k, 1.65MiB
171          webm       audio only DASH audio  136k , vorbis@128k, 1.66MiB
160          mp4        256x144    144p  112k , avc1.4d400c, 12fps, video only, 1.43MiB
278          webm       256x144    144p  133k , webm container, vp9, 24fps, video only, 1.33MiB
133          mp4        426x240    240p  251k , avc1.4d4015, 24fps, video only, 3.22MiB
242          webm       426x240    240p  304k , vp9, 24fps, video only, 2.71MiB
243          webm       640x360    360p  559k , vp9, 24fps, video only, 4.82MiB
134          mp4        640x360    360p  623k , avc1.4d401e, 24fps, video only, 4.94MiB
244          webm       854x480    480p 1018k , vp9, 24fps, video only, 8.16MiB
135          mp4        854x480    480p 1114k , avc1.4d401e, 24fps, video only, 9.08MiB
247          webm       1280x720   720p 2056k , vp9, 24fps, video only, 15.98MiB
136          mp4        1280x720   720p 2216k , avc1.4d401f, 24fps, video only, 16.75MiB
248          webm       1920x1080  1080p 3608k , vp9, 24fps, video only, 29.37MiB
137          mp4        1920x1080  1080p 4155k , avc1.640028, 24fps, video only, 32.52MiB
17           3gp        176x144    small , mp4v.20.3, mp4a.40.2@ 24k, 1.08MiB
36           3gp        320x180    small , mp4v.20.3, mp4a.40.2, 2.99MiB
18           mp4        640x360    medium , avc1.42001E, mp4a.40.2@ 96k, 7.80MiB
43           webm       640x360    medium , vp8.0, vorbis@128k, 9.82MiB
22           mp4        1280x720   hd720 , avc1.64001F, mp4a.40.2@192k (best)

Infine, per scaricare in un formato predefinito, basta usare il flag -f seguito dal numero corrispondente (prima colonna dell'output precedente) al formato voluto. Volendo quindi scaricare il video in formato mp4 a una risoluzione di 426x240 il comando diventerà quindi:

youtube-dl -f 133 https://www.youtube.com/watch?v=11VGDAOVEag

Un'ultima nota; youtube-dl non scarica solo i video di youtube, come il nome potrebbe erroneamente far pensare: la lista di siti supportati è infatti molto ampia (https://rg3.github.io/youtube-dl/supportedsites.html)

Può capitare di dover dividere un file di testo contenente una lunga lista in più file con un numero predefinito di righe ognuno.

Per eseguire il compito basta aprire un terminale, posizionarsi nella directory contenente il file da suddividere e dare il comando:

split -l 100 file_lungo.txt

Con il comando sopra descritto si otterranno tanti file da 100 linee ognuno. Il nome dei file sarà di default la lettera x seguita da suffissi in ordine alfabetico (xaa il primo file, xab il secondo xac il terzo e così via). È possibile scegliere un prefisso diverso aggiungendolo alla fine del comando. Volendo quindi usare il prefisso file_corto il comando diventerà:

split -l 100 file_lungo.txt file_corto