ChessX: Aggiungere un motore (Stockfish)

Dopo l’articolo in cui veniva spiegato come installare ChessX su un PC GNU/Linux, vediamo oggi come aggiungere un motore al programma in modo che si possano fare analisi di partite. Il motore scelto è Stockfish.

Per prima cosa occorre scaricare Stockfish e compilarlo sul sistema. Siccome è gestito su github, per scaricare i sorgenti sotto controllo di configurazione occorre avere git installato sul proprio PC. Se non presente, dare quindi il comando:

$ sudo apt-get install git

Una volta installato git scaricare i sorgenti di Stockfish con il comando:

user:~$ git clone https://github.com/mcostalba/Stockfish.git stockfish
Cloning into 'stockfish'...
...
user:~$ _

Se tutto è andato bene viene creata una directory stockfish con all’interno i sorgenti. Per compilare, entrare nella directory stockfish/src e dare il seguente comando:

user:src$ make profile-build ARCH=x86-64-modern

NOTA: l’uso dell’architettura x86-64-modern va bene se avete un PC nuovo basato sulle recenti architetture Intel, altrimenti potete provare con x86-32 per PC vecchi o anche x86-64 su architettture a 64 bit di cui non siete completamente sicuri della “modernità” (o se avete problemi con la modern).

Se tutto è andato bene all’interno della directory deve comparire un file eseguibile di nome stockfish. Copiatelo dove preferite e provate a lanciarlo. Se tutto va bene deve comparire un messaggio e il programma rimane in attesa:

pf:stockfish$ ./stockfish
Stockfish 211113 64 SSE4.2 by Tord Romstad, Marco Costalba and Joona Kiiski
_

Dare Ctrl-C per uscire dal programma.

Il secondo passo da compiere consiste nell’associare a Stockfish il suo database delle aperture. Scaricarlo dalla pagina dei download del sito, decomprimere l’archivio e copiare il file Book.bin nella directory dove si trova l’eseguibile di Stockfish creato in precedenza.

Passando a questo punto a ChessX, vediamo come agganciare il motore.

Andare nel menù Edit e scegliere “Preferences”, qui selezionare il tab “Engines” e cliccare sul pulsante “Add”. Cercare l’eseguibile di Stockfish e selezionarlo. Nella linea “Directory” selezionare la directory dove si trova l’eseguibile di Stockfish (e il file Book.bin).

Finestra Preferences/Engines dopo il setup di Stockfish
ChessX: Finestra Preferences/Engines dopo il setup di Stockfish

Come ultimo passo prima di chiudere la finestra delle preferenze, cliccare su “Options”. Si entra così nella finestra per il setup dei parametri UCI (Universal Chess Interface, il protocollo con cui la GUI comunica con il motore). Qui per il momento è importante solo impostare il nome del database delle aperture. Cambiare quindi il parametro “Book File” assegnandogli il valore “Book.bin“.

ChessX: finestra per le impostazioni delle opzioni UCI
ChessX: finestra per le impostazioni delle opzioni UCI

A questo punto per dimostrare che il motore funziona basta impostare una posizione (menù Edit -> Setup Position), aprire il pannello di Analisi (View -> Analysis) e cliccare sul pulsante “Analysis”. Io ho provato con il seguente matto in otto mosse tratto da “Strategia e tattica degli scacchi” di Georgij Lisitsyn:

Il bianco muove e da matto in 8 mosse
Il bianco muove e da matto in 8 mosse

Quello che mi piacerebbe molto fare a questo punto sarebbe utilizzare il motore per giocare una posizione contro di lui. Questa è una funzionalità molto utile per allenarsi per esempio nei finali. Purtroppo però questo allo stato di sviluppo attuale del programma non è possibile. L’unica cosa che si può fare è analizzare una partita, cosa che vedremo in una prossima puntata.

Per allenarsi a giocare posizioni contro un’engine la soluzione più economica consiste probabilmente nell’installare una GUI semplice come ad esempio XBoard. e associarci il motore Stockfish. Operazioni banali, sulle quali non starò a dilungarmi.

Manipolazione file audio da command line, alcuni esempi

Della serie “Il potere della Linea di Comando” o anche “May the force (of the Command Line) be with you” vediamo come manipolare file audio da linea di comando tramite le utility che si possono trovare sui sistemi GNU/Linux.

In particolare, i tool utilizzati oggi sono:

  • cuetools: “set of utilities for working with Cue Sheet (cue) and Table of Contents (toc) files“.
  • shntool: “multi-purpose tool for manipulating and analyzing WAV files”
  • vorbis-tools: comandi vari per la generazione e manipolazione di file OGG

Obiettivo: dato un album contenuto in un unico file in formato FLAC e indicizzato tramite un file CUE, generare un file OGG per ogni traccia.

L’operazione è composta da due fasi:

  • Dividere il file FLAC in tanti file, uno per traccia
  • Convertire i file ottenuti in OGG cercando di inserire anche qualche tag estratto dal CUE

Prima proposta di soluzione (semplice ma sbagliata)

Passo (1): Generazione di tanti file WAV uno per traccia dandogli come nome split-trackNN.wav dove NN è il numero della traccia.

$ cuebreakpoints cue_file.cue | shnsplit audio_file.flac

Passo (2): conversione in formato OGG.

$ oggenc *.wav

Per fare tutto con un unico comando è anche possibile dire a shnsplit di effettuare direttamente la conversione in OGG:

$ cuebreakpoints cue_file.cue | shnsplit -o 'cust ext=ogg oggenc - -o %f' audio_file.flac

con questo comando si creano direttamente i file split-trackNN.ogg.

Seconda soluzione (leggermente più complicata, ma migliore)

Un metodo alternativo per leggere il file CUE consiste nel farlo leggere direttamente al comando shnsplit tramite l’opzione -f. In questo modo il comando cuebreakpoints non è più necessario e soprattutto, come vedremo, sarà facile dare ai file generati un nome più significativo.

Il comando è:

$ shnsplit -o 'cust ext=ogg oggenc - -o %f' -f cue_file.cue audio_file.flac

NOTA: Un problema minore di questo modo di lavorare è che, almeno in alcuni casi, viene creato anche un file di indice 00 che contiene un “pre-gap”. Di fatto è un file molto breve senza audio. Non ho trovato un modo per evitare di generarlo, per cui se viene creato va semplicemente cancellato dopo la conversione.

Il grosso vantaggio dell’opzione -f è invece che leggendo il file CUE direttamente è possibile nominare i file che vengono creati in modo automatico utilizzando le informazioni di traccia presenti nel file CUE. L’opzione da utilizzare è -t.

Per esempio per creare i file nel formato NN_-_TrackTitle.ogg (NN = track number) si può utilizzare il seguente comando:

$ shnsplit -o 'cust ext=ogg oggenc - -o %f' -t "%n_-_%t" -f cue_file.cue audio_file.flac

Se si vuole, si può anche utilizzare l’opzione -m per evitare l’uso di caratteri speciali nei nomi di file. Per esempio, per utilizzare il carattere underscore al posto degli spazi si può dare il seguente comando:

$ shnsplit -o 'cust ext=ogg oggenc - -o %f' -t "%n_-_%t" -m \ _ -f cue_file.cue audio_file.flac

Come inserire i tag nei file OGG

Vediamo infine come inserire le informazioni di album e traccia (tag) nei file OGG generati. E’ tutto molto semplice, basta utilizzare il comando cuetag:

$ cuetag cue_file.cue *.ogg

N.B: per evitare di avere errori ricordarsi di cancellare il file pregap di indice 00 eventualmente creato da shnsplit.

Per controllare il valore dei tag inserito nei file OGG si può utilizzare il comando vorbiscomment.

$ vorbiscomment file_ogg.ogg

CREDITS: Siti consultati:

Manipolazione file PDF, altri esempi

Oggi un amico mi ha passato alcune pagine scannerizzate da una rivista in formato PDF (un file per pagina).

Primo esercizio unire le pagine. Come detto in un precedente post, per fare queste cose uso tool command line, in particolare anche qui si presta bene  pdftk. Per unire più file basta il comando:

user@host:~$ pdftk file1.pdf file2.pdf file2.pdf output output_file.pdf

E i tre file indicati vengono incollati insieme nel file output_file.pdf.

Secondo esercizio. Non ero soddistatto dalla dimensione a mio parere eccessiva del file risultante (dovuta alla dimensione dei file di partenza) e allora ho cercato un modo per ridurre la dimensione. A parte il fatto che sicuramente esisteranno altri metodi usando anche il solito pdftk, ho trovato una soluzione curiosa che consiste nel convertire il file PDF prima in formato Postscript poi indietro nuovamente in formato PDF. Il tutto utilizzando i tool command line che vengono con un altro programma, Ghostscript.

I comandi da dare sono i seguenti:

user@host:~$ pdf2ps output_file.pdf output_file.ps

user@host:~$ ps2pdf output_file.ps new_file.pdf

Il file intermedio, output_file.ps, essendo Postscript è ben più grosso del PDF originario, ma il PDF risultante dal secondo passo è (almeno nel mio caso) 5 volte più piccolo di quello di partenza, senza notare una perdita significativa nella qualità del risultato. Probabilmente il comando ps2pdf utilizza automaticamente un qualche algoritmo di compressione, fatto sta senza particolare fatica ho ottenuto il risultato richiesto.

ChessX: Installazione sotto GNU/Linux

In un precedente articolo abbiamo introdotto ChessX, un gestore di Database per partite di scacchi che ho deciso di provare sul mio nuovo PC con linux (Ubuntu 12.10). In questo primo articolo vedremo come installarlo, cosa che può risultare a prima vista problematica visto che il programma non è disponibile su nessun repository della distribuzione Ubuntu e per questo va scaricato come sorgente e compilato sulla macchina dove si vuole utilizzare.

La pagina per la compilazione sul sito di ChessX è piuttosto spartana e non da indicazioni su come preparare il PC, il che, soprattutto per un utente non specialista, può essere un problema. Il programma utilizza le librerie Qt, ed è quindi necessario installarle insieme a tutti i tool necessari per la compilazione dei programmi in tale ambiente. Fortunatamente non è complicato soprattutto perché Ubuntu fornisce una serie di tool che rendono facile questa operazione. Uno di questi tool, auto-apt, lo ho scoperto per l’occasione.

Come al solito i motori di ricerca aiutano, e dopo una rapida ricerca ho trovato una pagina di un utente Google+ (thank you very much Mr. Summers!) che spiega pressoché tutto. Per installare un’ambiente di sviluppo per Qt4 basta quindi dare da command line i seguenti comandi:

user@host:~$ sudo apt-get install libqt4-dev
user@host:~$ sudo apt-get install auto-apt
user@host:~$ sudo auto-apt update-local
user@host:~$ sudo auto-apt update
user@host:~$ sudo auto-apt updatedb

Siccome voglio utilizzare la versione attualmente sotto sviluppo (non è detto che non riesca anche a trovare un po’ di tempo per contribuire al progetto), occorre installare anche subversion:

user@host:~$ sudo apt-get install subversion

A questo punto per scaricare su una directory locale i sorgenti attualmente in sviluppo dare il seguente comando:

user@host:~$ svn co http://svn.code.sf.net/p/chessx/code/trunk chessx

NOTA: in alternativa è possibile scaricare l’ultima versione ufficialmente rilasciata andando nella pagina dei download e cliccando sull’opportuno link che rimanda ai sorgenti dell’ultima release (ad oggi, novembre 2013, è la 1.0.0 “Beetle”).

Finalmente c’è tutto, per compilare i comandi da dare sono i seguenti:

user@host:~$ cd chessx
user@host:~$ qmake
user@host:~/chessx$ sudo auto-apt run make

Se tutto è andato bene, per eseguire il programma, nel caso si sia utilizzata la versione di sviluppo (presa con subversion) dare i seguenti comandi:

user@host:~/chessx$ cd release
user@host:~/chessx/release$ ./chessx

oppure, nel caso si sia presa la versione di rilascio:

user@host:~/chessx$ cd bin
user@host:~/chessx/bin$ ./chessx

Ecco a riprova del mio “successo” la prima schermata dell’applicativo appena lanciato!

 

ChessX - Schermata di avvio
ChessX – Schermata di avvio

Alla prossima puntata!

 

Letture interessanti, 24 gennaio 2012

Un po’ di letture interessanti sul web che ho fatto negli ultimi giorni.

  • In primis, il sempre chiaro ed efficace Luigi Zingales, sul sito del Sole 24 Ore con un articolo dal titolo “Il coraggio di cambiare” fa considerazioni a mio parere molto condivisibili sulla brutta faccenda del Monte dei Paschi di Siena.
  • Poi, un articolo su Il Post relativo alla rimozione di un’applicazione dallo Apple Store. Sono questo genere di cose (oltre al costo ovviamente!) che oggi mi tengono lontano da oggetti della Apple. A quasi 50 anni suonati non ho certo bisogno che qualcuno mi dica cosa posso o non posso fare con i miei giocattoli.
  • Passando ai siti esteri, su ArsTechnica, una lettura interessante (un po’ per specialisti lo ammetto) su come nei prossimi anni potrà forse cambiare il metodo di rilascio della popolare distribuzione GNU/Linux Ubuntu: “Ubuntu considers huge change that would end traditional release cycle
  • Ecco poi un bel tutorial su come fare fotografie del cielo stellato con un’attrezzatura non particolarmente sofisticata: Da SteveHuffPhoto: “How to shoot: Wide Field Astrophotography With a Camera and Tripod by Chris Malikoff
  • Infine per gli appassionati di scacchi, un’analisi video della splendida partita Aronian-Anand, giocata lo scorso 15 gennaio a Wijk aan Zee nel quarto turno del prestigioso torneo Steel 2013.

Scacchi su PC GNU/Linux: ChessX

Per chi vuole utilizzare un PC con sistema operativo GNU/Linux semplicemente per giocare a scacchi, o per effettuare operazioni più sofisticate come per esempio analizzare le proprie partite o costruire e gestire un database di partite, purtroppo le scelte non sono molte. Nessuno dei programmi maggiormente utilizzati dai giocatori, amatori e professionisti, hanno una versione per il sistema con il pinguino.

A compensare – molto in parte – provvedono i soliti volenterosi dell’open source che mettono a disposizione diversi programmi dalle caratteristiche che, se non arrivano a competere con quelle dei programmi commerciali, sono sono comunque non disprezzabili.

Il problema principale non sono le “engine”, i motori, da utilizzare per giocare contro il computer o per analizzare le partite (di queste ce ne sono diverse anche molto forti), bensì le GUI e i programmi per mantenere database di partite, cioè il tipo di programmi più apprezzati dai professionisti e dai giocatori di circolo.

Il programma che storicamente ha avuto il ruolo maggiore in questo contesto è Scid. In passato lo ho utilizzato (o meglio ho utilizzato una delle sue varianti più complete, ChessDB), ed è sicuramente un buon programma. Il suo problema maggiore è che il suo sviluppo è ormai fermo da tempo, mentre uno più veniale è che risente di una interfaccia utente oramai piuttosto “antica”.

Premesso che in ogni caso mi sento di consigliare senza problemi i programmi prima citati, a questo giro voglio provare a investire un po’ di tempo per provare a utilizzare un altro programma che oggi risolve almeno in parte i problemi sopra citati e cioè ChessX. L’interfaccia è moderna e c’è un team di sviluppatori che ad oggi lo sta portando avanti (seppur con la lentezza tipica dei progetti open-source sviluppati senza “sponsor” e solo per passione da persone che nella vita “reale” fanno ben altro).

Inizio quindi una serie di articoli su questo argomento. Nella prossima – prima – puntata vedremo come installare il programma su una macchina GNU/Linux a partire dai sorgenti scaricabili dal sito.

Un potente programma per manipolare file PDF: pdftk

Ultimamente mi sto appassionando alle scienze economiche e una delle prime cose che ho imparato è che se ci sono due modi di fare una cosa allo stesso modo, è meglio scegliere quella più economica, che sia in termini di spesa o di tempo da investirci.

Questo principio trova una grande applicazione sull’uso degli applicativi da linea di comando sui PC con GNU/Linux. Uno dei grandi vantaggi di questa piattaforma è infatti la disponibilità di comandi molto potenti da lanciare da terminale, con i quali è possibile fare praticamente qualsiasi cosa.

Vediamo allora un’applicazione del principio di economia (spero si dica così): è davvero necessario spendere soldi e installare complessi applicativi grafici che portano via spazio disco e risorse al sistema per fare delle semplici operazioni come estrarre delle pagine da un documento PDF?

Sicuramente no. Infatti per fare operazioni di questo tipo basta un semplice applicativo command line come pdftk (PDF toolkit).

Supponiamo di voler estrarre da un documento PDF di 100 pagine le pagine da 10 a 20. Usando pdftk questa cosa si fa facilmente aprendo un terminale ed inserendo il seguente semplice comando:

user@host:~$ pdftk input_file.pdf cat 10-20 output output_file.pdf

Questo comando estrae dal file input_file.pdf le pagine salvandole nel file output_file.pdf.

Con questo semplice ma potente programma è ovviamente possibile fare anche molte altre cose, ma per oggi il mio tempo si è esaurito. Provate a dare un’occhiata alla man page o alla documentazione sul sito del programma.

Un potente programma per effettuare backup: rsync

Un ringraziamento preventivo a Matteo, che a suo tempo, in un progetto in cui lavoravamo insieme, si occupò di determinare le migliori opzioni da utilizzare con il comando rsync per l’implementazione delle operazioni descritte in questo articolo.

Una delle utility più interessanti per effettuare copia di file, sincronizzazione di directory e backup nell’ecosistema GNU/Linux è il programma rsync. Come molto spesso capita, dietro l’apparenza banale di una utility command line si nasconde un programma molto potente che laconicamente si autodefinisce “a fast, versatile, remote (and local) file-copying tool“.

In questo articolo si dimostrerà come utilizzare la funzionalità di sincronizzazione tra directory offerta dal programma per copiare il contenuto di una directory in una seconda area. L’applicazione è ovvia: effettuare il backup della prima directory (che nel seguito chiameremo “primaria”) nella seconda (definita “secondaria”).

Per rendere più interessante la dimostrazione supporremo che le due directory risiedano su due PC diversi (ma le stesse operazioni possono essere effettuate anche con le due aree poste sullo stesso PC). Naturalmente occorre che i due PC siano connessi in rete possibilmente senza firewall nel mezzo che potrebbero bloccare le porte necessarie a rsync per lavorare.

La configurazione rsync scelta è quella client-server:

  • lato directory primaria si manterrà il programma in esecuzione come demone (server) pronto a rispondere alle interrogazioni dei client
  • lato directory secondaria si lancerà il comando da linea di comando (client); al termine di ogni sincronizzazione il programma esce.

Nel seguito indicheremo ip_server l’indirizzo IP del server e con ip_client quello del client.

Installazione

Normalmente rsync è già presente di default sulle più diffuse distribuzioni GNU/Linux. Nel caso non fosse presente, installarlo seguendo le procedure standard della distribuzione. Per esempio su Debian/Ubuntu e derivati dare il comando:

sudo apt-get install rsync

Configurazione e startup demone lato server

Per prima cosa definiamo la directory di cui si vuol effettuare il backup. Supponiamo sia /home/user/workarea. Supponiamo che al suo interno sia presente un unico file di nome foo.bar.

Come seconda cosa occorre preparare il file di configurazione per il server rsync. Supponiamo sia /home/user/rsyncd.conf. Nel nostro esempio il suo contenuto deve essere il seguente:

[WorkArea]
path=/home/user/workarea/
log=/home/user/logs/rsyncd.log
max verbosity

A questo punto per lanciare il server il comando da dare è il seguente:


user@host:~$ sudo rsync --daemon --config=/home/user/rsyncd.conf
user@host:~$ _

Se si controlla con il comando ps si vedrà il server in esecuzione.

Sincronizzazione lato client

Prima di effettuare la sincronizzazione vera e propria può essere utile lanciare il comando in modalità “dry-run”: si interroga il server per capire se deve essere effettuata un’operazione di sincronizzazione, cioè se lato server ci sono dei file nuovi o se alcuni file sono stati modificati. Per effettuare l’operazione il comando da dare è il seguente:


user@host:~$ rsync --dry-run -v --force --delete -a --port=873 <ip_server>::WorkArea workarea_backup
created directory workarea_backup
./
foo.bar
sent 36 bytes received 77 bytes 226.00 bytes/sec
total size is 56 speedup is 0.50 (DRY RUN)

Dall’output del comando si capisce che c’è la directory root della workarea modificata e il file foo.bar  modificato. Si capisce anche che verrebbe creata la directory di destinazione del backup, workarea_backup. Vediamo nel dettaglio il significato dei parametri utilizzati:

  • --dry-run: non effettua alcuna operazione, mostra solo le operazioni che verrebbero effettuate se non ci fosse questa opzione
  • -v: aumenta la verbosità delle informazioni mostrate a schermo
  • --force: forza la cancellazione delle directory non più esistenti anche se non vuote
  • --delete: se da server sono stati cancellati dei file ancora presenti nell’area di backup (come risultato di una precedente sincronizzazione), questi vengono cancellati
  • --port=873: cerca il server sulla porta 873 (la porta standard del comando rsync)
  • <ip_server>::WorkArea: indirizzo IP del server e “stanza” del file di configurazione con le informazioni dell’area da sincronizzare
  • workarea_backup: directory locale dove salvare il contenuto della sincronizzazione. Da notare che il contenuto di questa directory viene modificato in modo da rispecchiare il contenuto dell’area sul server, per cui eventuali file estranei verrebbero cancellati.

A questo punto, per effettuare la sincronizzazione ripetere il comando senza l’opzione –dry-run:

user@host:~$ rsync -v --force --delete -a --port=873 <ip_server>::WorkArea workarea_backup
created directory workarea_backup
./
foo.bar
sent 36 bytes received 77 bytes 226.00 bytes/sec
total size is 56 speedup is 0.50 (DRY RUN)

Verificare il contenuto della directory workarea_backup: adesso contiene il file foo.bar presente sul server.

D’ora in avanti, per mantenere aggiornata la directory di backup, basterà ripetere periodicamente il comando sul client.

Bonus track: uso di netcat per controllare lo stato di una porta

Infine un “bonus track” per vedere come lato client si può utilizzare la utility netcat per controllare se il server è attivo. Questo può essere utile soprattutto in script per controllare che il server sia presente prima di inoltrare i comandi visti in precedenza.

Come dice la sua manpage, “The nc (or netcat) utility is used for just about anything under the sun involving TCP or UDP“. In questo caso noi la useremo dal client per controllare che il server rsync sia in esecuzione. La porta su cui sta in ascolto il server rsync è la 873. Il comando netcat da dare per controllare se il server è attivo è il seguente:

user@host:~$ nc -z -n -w 1 <ip_server> 873
user@host:~$ _

Il significato delle opzioni è il seguente:

  • -z: effettua uno scan della porta senza inviare pacchetti
  • -n: non usa DNS
  • -w 1: imposta il timeout di attesa della risposta a 1 secondo

Il comando come spesso capita sulla command line di sistemi GNU/Linux, laconicamente, non scrive niente. Per controllare l’esito dell’interrogazione occorre verificare il valore ritornato dal comando tramite l’analisi della variabile $?. Se il valore di questa variabile è 0 vuol dire che il server è attivo (qualcuno è in ascolto sulla porta 873), altrimenti il server non risponde (nessuno è in ascolto sulla porta 873.

L’analisi della valore di ritorno del comando nc può essere fatto tramite il comando echo:

user@host:~$ echo $?
0
user@host:~$ _

o tramite, per esempio, tramite il seguente snippet di codice bash:

nc -z -n -w 1 <ip_server> 873
if [ $? -eq 0 ]; then
echo "rsync server is running!"
else
echo "rsync server not running"
fi

Screencasting su linux

Lo Screencasting è la procedura utilizzata su un PC, o altro dispositivo, per registrare video e audio dal desktop. Attraverso l’uso di opportuni software è possibile ottenere uno screencast, un video, corredato di traccia audio che descrive, di solito meglio di 1.000 parole, una procedura da seguire su PC. Di esempi di screencast è pieno il mondo, a titolo di esempio qui sotto se ne può vedere uno tratto dal sito Pragmatic Programming (che tralaltro screencast li produce e li vende).

Realizzare screencast è facile. Esistono vari software per farlo, alcuni gratuiti, altri a pagamento. Qui descriverò un metodo per macchine linux. Il programma da utilizzare è recordmydesktop.

Per installarlo su macchine Debian/Ubuntu è possibile utilizzare il seguente comando, (anche se l’equivalente esiste sicuramente per le altre distribuzioni):

sudo apt-get install recordmydesktop

Una volta ottenuto il software, per registrare l’intero desktop basta lanciare il comando:

recordmydesktop

una volta terminata la registrazione interrompere il programma con Ctrl-C e lasciare terminare l’encoding del file multimediale. Il file generato dal programma è in formato OGV. Non entro nel merito dei formati multimediali perché l’argomento è vasto e complesso e attualmente fuori dalla mia portata. L’unica cosa che vale la pena menzionare è che il formato OGV non è ben supportato da macchine non linux e anche YouTube per esempio sembra non gestirlo (a dire il vero oggi non ho provato).

Il file ottenuto va quindi convertito in un formato video più “tradizionale” (qualunque cosa questo significhi) e per farlo si possono utilizzare vari programmi. Qui menziono quelli che ho provato io:

  • mencoder: per esempio con il seguente comando:

mencoder -idx <file_input.ogv> -ocv lavc -oac mp3lame -o <file_output.avi>

si ottiene un file AVI. Nella prova fatta stanotte, nel file risultante dalla conversione, ho però ottenuto un disallineamento tra la traccia audio e quella video che di fatto rendeva il prodotto inutilizzabile.

  • avconv: questo programma è l’evoluzione del famoso ffmpeg (quest’ultimo ad oggi dichiarato obsoleto) e a tutti gli effetti lo sostituisce. Trattasi di un programma molto complesso e potente con molte opzioni che permettono di determinare il formato e la qualità della traccia audio e video risultante sul file di output. Con il seguente comando sono riuscito a convertire un OGV in modo corretto e a farlo riprodurre senza problemi da YouTube:

avconv -i <file_input.ogv> -f avi -c:v mpeg4 -b:v 800k -g 300 -bf 2 -c:a mp2 <file_output.avi>

Al momento non sono molto soddisfatto della qualità del video, e non sono riuscito a codificare la traccia audio in MP3, ma almeno il file risultate ha una dimensione gestibile e funziona.

Per oggi solo un’ultima nota. Spesso per uno screencast risulta utile registrare il contenuto di un’unica finestra. Per fare questo con recordmydesktop basta utilizzare l’opzione --windowid. Per esempio:

recordmydesktop --windowid 0x2a00006

Per scoprire il window id della finestra da registrare, lanciare per esempio il comando:

xwininfo | awk '/xwininfo: Window id/{print $4}'

e  cliccare con il mouse sulla finestra di interesse.

Per oggi è tutto.