mplayer

Siccome ho iniziato a studiare l'incredibile suite multimediale opensource mplayer/mencoder con questo articolo inizia una rubrica dove descrivo e annoto i miei progressi. In questo primo lavoro descrivo uno script che permette di registrare da un ingresso composito

mencoder tv:///2 -tv driver=v4l2:input=1:norm=pal:width=480:height=360:outfmt=yuy2:device=/dev/video0:adevice=/dev/dsp:audiorate=32000:forceaudio:forcechan=1:buffersize=80 -ovc lavc -lavcopts threads=3:vcodec=mpeg4:vbitrate=1200:keyint=30 -oac mp3lame -lameopts br=128:cbr:mode=3:vol=8 -ffourcc divx -endpos 120 -o VHS.avi

tv:/// setta l'input della scheda di acquisizione, il valore 2 restituisce l'ingresso composto, almeno per la mia scheda saa7134

driver=v4l2:input=1:norm=pal:width=480:height=360:outfmt=yuy2:device=/dev/video0:adevice=/dev/dsp:audiorate=32000:forceaudio:forcechan=1:buffersize=80

-tv questa opzione permette di gestire diverse proprietà della scheda di acquisizione

driver=v4l2 permette di scegliere il driver d'ingresso , nel nostro caso v4l2

input Specifica l'ingresso, default: 0 (TV), 1 sta per ???

norm=pal standard TV europeo, le alternative sono PAL, SECAM, NTSC

width=480:height=360 setta le dimensioni della finestra

outfmt=<value> Specifica l'output del tuner utilizzando un preset supportato dal driver V4L (yv12, rgb32, rgb24, rgb16, rgb15, uyvy, yuy2, i420)

device=/dev/video0 specifica il device video

adevice=/dev/dsp seleziona l'audio device, sebbene stando alla manpage di mplayer la formula /dev/xxx dovrebbe essere utilizzata con OSS nella mia esperienza funziona molto bene

forceaudio Cattura l'audio sebbene non sia rivelato nessun device audio da v4l (forse per questo funziona bene l'opzione precedente).

Forcechan=1 Questa opzione permette di forzare le registrazioni in stereo o mono (rispettivamente valori 1 e 2)

buffersize=80 Dimensione massima del buffer espressa in mb (default=dinamico)

audiorate=32000 setta la cattura audio al bitrate di 32000

-ovc lavc -lavcopts threads=3:vcodec=mpeg4:vbitrate=1200:keyint=30

− ovc lavc (−lavcopts) Codifica video utilizzando le libreria libavcodec

threads=3 setta il numero massimo di “ threads” da utilizzare, il valore di default è 1 (1-8) potrebbe avere un leggero effetto negativo sulla valazione del motion

vcodec=mpeg4 indica lo specifico codec da utilizzare, l'opzione di default è mpeg4, ecco i vari codec utilizzabili

asv1 (ASUS Video v1), asv2 (ASUS Video v2), dvvideo (Sony Digital Video), ffv1 (FFmpeg’s lossless video codec), ffvhuff (nonstandard 20% smaller HuffYUV using YV12), flv (Sorenson H.263 used in Flash Video ), h261 (H.261), h263 (H.263), h263p (H.263+), huffyuv (HuffYUV), libtheora (Theora) libx264 (x264 H.264/AVC MPEG-4 Part 10), libxvid (Xvid MPEG-4 Part 2 (ASP)), ljpeg (Lossless JPEG), mjpeg (Motion JPEG), mpeg1video (MPEG-1 video), mpeg2video (MPEG-2 video), mpeg4 (MPEG-4 (DivX 4/5)), msmpeg4 (DivX 3), msmpeg4v2 (MS MPEG4v2), roqvideo (ID Software RoQ Video), rv10 (an old RealVideo codec), snow (also see: vstrict) (FFmpeg’s experimental wavelet-based codec), svq1 (Apple Sorenson Video 1), wmv1 (Windows Media Video, version 1 (AKA WMV7)), wmv2 (Windows Media Video, version 2 (AKA WMV8))

vbitrate=1200 imposta il bitrate a 1200 Kbit

keyint=30 setta il massimo intervallo fra gli IDR-frames (default=250). Valori più grandi salvano i bits cosi che migliorano la qualità al costo delle precisione di ricerca

-oac mp3lame -lameopts br=128:cbr:mode=3:vol=8

-oac mp3lame codifica in mp3 utilizzando la libreria lame

-lameopts serve a settare le opzione di lame

-br=128:cbr nel modalità CBR indica il bitrate/s in kbps, mentre nella modalità VBR indica il valore minimo per frame i valori permessi sono <32-384> per cbr e >112 per VBR.

mode=3 setta la modalità audio come mono, (mode=<0−3>, 0 stereo, 1 joint-stereo, 2 dualchannel, 3 mono)

vol=8 audio input gain range, vol=<0−10>

-ffourcc divx puo essere utilizzata per sovrascrivere il video fourcc del file output

-endpos 120 fine della registrazione dopo 120 secondi,

-o VHS.avi salva tutto nel file -0 VHS.avi

esportare le mapage

Molto spesso quando si consultano corpose mapage di programmi complessi come ad esempio mplayer/mencoder si sente l'esigenza esportarle in formati più gestibili magari anche adatti alla stampa come il pdf. Questa operazione è in realtà molto semplice basta eseguire i seguenti comandi da shell

man -t mplayer> mplayer.ps

ps2pdf mplayer2.ps mplayer2.pdf

Result Code: NS_ERROR_FAILURE (0x80004005) Component

Ho provato ad installare la verione 3.0.12 r54655 per MacOSX di VirtualBox

Il programma all'avvio della macchina virtuale anadav in crash mostrando il seguente messaggio:

ERRORE

Result Code:

NS_ERROR_FAILURE (0x80004005)

Component:

Console

Interface:

IConsole {0a51994b-cbc6-4686-94eb-d4e4023280e2}

,,,,,,,,

Soluzione

Editare il file xml della macchina virtuale impostando il valore HardwareVirtEx come falso .

Path del file

/Users/username/Library/VirtuaBox/Machines/nome_macchina/nome_macchina.xml

Voce del file da editare.

<Hardware>

<CPU count="1">

<HardwareVirtEx enabled=" false"/>

<PAE enabled="true"/>

</CPU>

aumentare la velocità di avvio di openoffice

Oggi vi parlerò di un sistema per aumentare la velocità di startup di openoffice che io personalmente trovo tremendamente lunga. Bisogna andare nel munu strumenti e poi selezionare la voce opzioni. Quindi spostarsi nel menu memoria principale ed settare i paramentri per le seguintui voci come illustrato qui di seguito:

chache grafica

usa per openoffice 128 (o anche di + sulla base della vostra scheda video=

Memoria per oggetto 20

Abilitare il quickstart sulla barra delle applicazioni

Inoltre per aumentare ulteriormente la velocità si può disabilitare l'utilizzo del java run time dal sotto menu java

backup sulle condivizioni windows

Oggi vi parlerò di un sistema che ho recentemente utilizzato per copiare i file dalla mia home ad una condivisione smb

Dipendenze: sono tutte presenti nei repo quindi installabili mediante synaptic

1. rsync

2. grsync

3. smbfs

sudo mount.cifs //indirizzo IP/cartella condivisa /mnt -o user=nome user

una volta eseguito il mount verificare che la directory è stata montata effettivamente utilizzando Nautilus e per finire

Per finire lanciare la comodo interfaccia grafica di rsync scivando in un terminale sudo grsync

annotare su PDF a mano libera

Oggi voglio parlarvi di tre interessanti applicazioni:

1. xournal

2. gournal

3. jarnal (cross platform)
   

Le tre applicazioni, sostanzialmente equivalenti, permettono la scrittura di testi con la tastiera e a mano libera utilizzando una tavoletta grafica o il mouse. Inoltre permettono anche di scrivere note, ed evidenziare i test testo sui file in formato PDF.

Il livello di funzioni fornite da questi programmi non ha nulla da invidiare a blasonati software proprietari del calibro di “Microsoft Windows Journal”, “Mimeo whiteboarding” e “Palm notepad”:

• Selezione multipla;

• Sctittura a mano libera;
  

• Matite di diverse dimensioni: grandi, medie e fini;

• Gomma;

• Evidenziatore;

• Digitazione testo;

• undo/redo;

• Inserire immagini;

• Caricare un file come background;

Seguire le dirette Rai in streaming: nuovi trucchi per vecchi programmi

Salve oggi voglio parlarvi di uno script molto interessante che permette di seguire le dirette Rai in streaming senza dover scaricare moonligth della novell e i codec proprietari di Microsoft.

Create il file .guardatv all’interno della vostra home e incollate il codice che trovate in appendice al suo interno e rendetelo eseguibile ($ chmod +x .guardatv)

Scaricate questo file PNG (con sfondo trasparente). Aprite un terminale e spostatevi nella directory dove avete scaricato l’immagine, e date il seguente comando:

#sudo cp linuxrai48.png /usr/share/pixmaps/

Ora aggiungete un avviatore nel pannello del vostro DE: Tasto destro del mouse sopra il pannello, aggiungi un nuovo elemento, avviatore. Ora mettete il nome e la descrizione che volete. Come comando inserite:

./.guardatv

e scegliete l’icona, indicate il percorso dove avete messo l’immagine, nel caso dell’esempio era:

/usr/share/pixmaps/linuxrai48.png

mettete il segno di spunta su “esegui nel terminale“, chiudete e guardate che figurone fa il nuovo pulsante per vedervi i programmi della Rai proprio nel vostro pannello.

Non vi sono particolari dipendenze oltre ai codec propietari e a VLC io ho dovuto scaricare il pacchetto dialog.

Ecco come appare sulla mia linuxbox

Linkografia

1. http://idl3.wordpress.com/2009/09/29/howto-guarda-i-canali-rai-con-gnulinux/

2. http://www.slacky.eu/wikislack/index.php?title=Rai.tv_senza_silverlight

#!/bin/bash
# Usate, modificate, riscrivete questo script come vi pare.
# se vi succede qualcosa di brutto a causa di questo script,
# io non c'ero, e se c'ero dormivo, ergo: sono cavoli vostri.
chiaro?

# versione: 0.2.1

## CONFIGURAZIONE UTENTE
tries=5                 #tentativi di scaricare ogni file
timeout=10              #tempo massimo di attesa risposta per lo
scaricamento (secondi)
player="vlc"    #nome del player video.
output="si"             #mandare a video i messaggi del player?
(si/no)
background="no" #mandare il player in background, in modo da aver
disponibile il terminale?

#per salvare gli stream, usate il vostro player preferito.
#per mplayer ad esempio, basta modificare la variabile "player" a:
# player="mplayer -dumpfile stream.wmv -dumpstream"

############ PROGRAMMA REALE ################
############ NON MODIFICARE! ################
NOTFOUND=""
for command in wget sed grep awk tail head dialog; do
    if [ -z "`which $command 2>/dev/null`" ]; then
            NOTFOUND="`echo "$NOTFOUND $command"`"
    fi
done
if [ -n "`which kdialog`" ]; then
    USEKDIALOG="true"
else
    USEKDIALOG="false"
fi
if [ -n "$NOTFOUND" ]; then
    echo "Comandi non trovati:"
    echo $NOTFOUND
    exit 1
fi
USERAGENT='Mozilla/5.0 (X11; U; Linux i686; it; rv:1.9.0.6)
Gecko/2009011912 Firefox/3.0.11'
PLAYERCMD="`echo $player|awk -F " " '{print $1}'`"
if [ -z "`which $PLAYERCMD 2>/dev/null`" ]; then
    echo "Player $PLAYERCMD non trovato!"
    exit 1
fi
unset PLAYERCMD
case $output in
    [Ss][Ii])
            ;;
    [Nn][Oo])
            ;;
    *)
            echo "La variabile \"output\" ammette solo"
            echo "I valori \"si\" e \"no\""
            exit 1
            ;;
esac
case $background in
    [Ss][Ii])
            ;;
    [Nn][Oo])
            ;;
    *)
            echo "La variabile \"background\" ammette solo"
            echo "I valori \"si\" e \"no\""
            exit 1
            ;;
esac
help () {
    echo "Script per la visualizzazione dei canali presenti su
rai.tv"
    echo "senza il plugin Silverlight di Microsoft o Moonlight
di Novell"
    echo "Creato da Luke88 -- luke88 _at_ slacky.it"
    echo -e "\nUso:\t$0 chiave_ricerca\tcerca canale nella
lista"
    echo -e "\t$0 tutti\t\tlista completa dei canali"
    echo ""
    echo "per configurare player e comportamenti del player"
    echo "cambiare le variabili all'inizio di questo scirpt"
    echo "con il vostro editor preferito"
    echo -e "\nlo script non porta con se garanzie di qualsiasi
tipo"
}
update () {
    echo "scarico la lista dei canali...."
    rm ${0}.xml &>/dev/null
    wget -U "$USERAGENT" --tries=$tries --timeout=$timeout -O
${0}.xml --tries=$tries
www.rai.tv/dl/RaiTV/videoWall/PublishingBlock-5566288c-3d21-48dc-b3e2-af7fbe3b2af8.xml
&>/dev/null
    if [ ! -s ${0}.xml ]; then
            echo "Download fallito! controlla la connessione
internet e rilancia il programma"
            exit 1
    fi
    rm ${0}.tmp &>/dev/null
    grep -B 1 '<url>' ${0}.xml|sed /--/d | sed s/^\ *//
> ${0}.tmp
    rm ${0}.xml &>/dev/null
    sed -i s/\&apos\;/\'/g ${0}.tmp
    sed -i 's/\&#224\;/à/g' ${0}.tmp
    sed -i 's/\&#225\;/à/g' ${0}.tmp
    sed -i 's/\&#232\;/è/g' ${0}.tmp
    sed -i 's/\&#233\;/é/g' ${0}.tmp
    sed -i 's/\&#236\;/ì/g' ${0}.tmp
    sed -i 's/\&#237\;/ì/g' ${0}.tmp
    sed -i 's/\&#242\;/ò/g' ${0}.tmp
    sed -i 's/\&#242\;/ò/g' ${0}.tmp
    sed -i 's/\&#249\;/ù/g' ${0}.tmp
    sed -i s/\&amp\;/\\\&/g ${0}.tmp
    sed -i s/\&quot\;/\'/g ${0}.tmp
    sed -i s/\&#039\;/\'/g ${0}.tmp
    COUNTER=0
    rm ${0}.canali &>/dev/null
    while read line ; do
            let "NUM=$COUNTER % 2"
            if [ $NUM -eq 0 ]; then
                    let "NUM=$COUNTER % 20" #facciamo vedere
qualcosa a schermo...
                    if [ $NUM -eq 0 ]; then
                            let "NUM=$COUNTER/2"    #ogni 10
stream diciamo a quanti siamo...
                            echo -n $NUM
                    else
                            echo -n "."
                    fi
                    echo -en $line|awk -F '"' '{print $2}'
>> ${0}.canali   #metti il nome dello stream in cache
            else
                    echo -en $line|awk -F '<url>' '{print
$2}'|awk -F '</url>' '{print $1}' >> ${0}.canali
#metti l'indirizzo dello stream in cache
                    echo "==" >> ${0}.canali        #non
è realmente necessario, ma se qualcuno si vuole vedere la lista
selza usare lo script
            fi                                             
        #fa comodo avere una lista leggibile
            let COUNTER++
    done < ${0}.tmp
    echo ""
    rm ${0}.tmp &>/dev/null
}
check_dwn () {
    if [ ! -s ${0}.tmp ]; then
            echo "Download fallito! controlla la connessione
internet e rilancia il programma"
            exit 1
    fi
}
play () {
    if [ -z "`echo $STREAM|grep 'mms://'`" ]; then
            #uff... tiriamo fuori lo stream da incasinamenti
vari....
            rm ${0}.tmp &>/dev/null
            wget -U "$USERAGENT" --tries=$tries
--timeout=$timeout --spider  "$STREAM" -O /dev/null 1> /dev/null
2> ${0}.tmp        #a volte il link è un file flv.
            check_dwn
            TMP="`tail -n 2 ${0}.tmp|grep 'flv'`"   #che sembra
essere solo un video....
            rm ${0}.tmp
            if [ -z "$TMP" ]; then
                    wget -U "$USERAGENT" --tries=$tries
--timeout=$timeout -O ${0}.tmp "$STREAM" &>/dev/null
                    check_dwn
                    if [ -z "`grep 'http://' ${0}.tmp`"
]&&[ -z "`grep 'mms://' ${0}.tmp`" ]; then
                            #mi è capitato che alcuni link
portino nel vuoto
                            echo "(muove la mano)--Tu *NON*
vuoi vedere questo canale"
                            rm ${0}.tmp
                            exit 1
                    else
                            if [ -n "`grep 'mms://' ${0}.tmp`"
]; then
                                    STREAM="`grep 'mms://'
${0}.tmp|awk -F '"' '{print $4}'`"
                            elif [ -n "`grep wmv ${0}.tmp`" ];
then
                                    STREAM="`grep wmv ${0}.tmp
|awk -F '"' '{print $2}'`"
                            else
                                    STREAM="`grep 'http://'
${0}.tmp`"
                               
#############################################################
                                    # Modifica 04/07/2009 -
jigen74
                                    # lo stream ha una forma
del tipo:
                                    # <ASX
VERSION="3.0"><ENTRY><REF HREF="..."
/></ENTRY></ASX>
                                    # per cui per recuperare
l'url corretto leggo il contenuto di HREF
                               
#############################################################
                                    if [ -n "`echo $STREAM|grep
'HREF'`" ]; then
                                            STREAM="`echo
$STREAM|awk -F 'HREF="' '{print $2}'|awk -F '"' '{print $1}'`"
                                    elif [ -n "`echo
$STREAM|grep '"'`" ]; then
                                            STREAM="`echo
$STREAM|awk -F '"' '{print $2}'`"
                                    fi
                                    rm ${0}.tmp
                                    wget -U "$USERAGENT"
--tries=$tries --timeout=$timeout --spider "$STREAM" -O /dev/null
1>/dev/null 2>${0}.tmp
                                    check_dwn
                                    if [ -z "`tail -n 2
${0}.tmp|grep 'flv'`" ]; then       #se NON è un flv...
                                            wget -U
"$USERAGENT" --tries=$tries --timeout=$timeout -O ${0}.tmp
"$STREAM" &>/dev/null
                                            check_dwn
                                            if [ -n "`grep
'mms://' ${0}.tmp`" ]; then
                                               
STREAM="`grep 'mms://' ${0}.tmp  |awk -F '"' '{print $2}'`"
                                            elif [ -n "`grep
'.flv' ${0}.tmp`" ]; then
                                               
STREAM="`cat ${0}.tmp`"
                                       
########################################################
                                            # Modifica
04/07/2009 - jigen74
                                            # sostituito else
con elif per il controllo
                                            # dell'estensione
.wmv
                                            # se lo stream non
ha estensione non va modificato
                                       
########################################################
                                            elif [ -n "`grep
'.wmv' ${0}.tmp`" ]; then
                                               
STREAM="`grep '.wmv' ${0}.tmp |awk -F '"' '{print $2}'`"
                                            fi
                                    fi
                            fi
                            #rm ${0}.tmp
                    fi
            fi
    fi
    case $output in
            [Nn][Oo])
                    case $background in
                            [Nn][Oo])
                                    $player "$STREAM"
&>/dev/null
                                    ;;
                            [Ss][Ii])
                                    $player "$STREAM"
&>/dev/null &
                                    ;;
                    esac
                    ;;
            [Ss][Ii])
                    case $background in
                            [Nn][Oo])
                                    $player "$STREAM"
                                    ;;
                            [Ss][Ii])
                                    $player "$STREAM" &
                                    ;;
                    esac
                    ;;
    esac
}
if [ "$1" == "-h" ]||[ "$1" == "--h" ]||[ "$1" == "-help" ]||[ "$1"
== "--help" ]; then
    help
    exit 0
fi
update
COUNTER=1
#costruiamo la lista variabili per il dialog.
#è una lista di elementi, del tipo
#nome1 "" help1 nome2 "" help2 ...
#il secondo elemento è volontariamente lasciato come lista vuota.
rm ${0}.list &>/dev/null

if [ "$1" == "tutti" ]||[ -z "$1" ]; then
    grep -v ^==$ ${0}.canali | \
    while read line; do
            case "$COUNTER" in
                    1)
                            if [ "$USEKDIALOG" == "true" ];
then
                                    TMP="`echo $line|sed 's/\
/_/g; s/_-_/_/g'`"
                            else
                                    echo \"$line\" >>
${0}.list             #"# <--ripristino la colorazione per
vim...
                            fi
                            COUNTER=2
                            ;;
                    2)
                            if [ "$USEKDIALOG" == "true" ];
then
                                    echo -e "`echo ${line}|sed
s/\ /%20/g` ${TMP}" >> ${0}.list
                            else
                                    echo -e \"\""\n"\"$line\"
>> ${0}.list  #"# <--ripristino la colorazione per vim...
                            fi
                            COUNTER=1
                            ;;
            esac
    done
else
    grep -A 1 -i "$1" ${0}.canali | grep -v -- ^--$ | grep -v
^==$ |\
    while read line ; do
            case "$COUNTER" in
                    0 )
                            COUNTER=1 #serve solo per 'saltare
un turno'
                            ;;
                    1 )
                            if [ -z "`echo $line|grep '://'`"
]; then       # se non è un url
                                    if [ "$USEKDIALOG" ==
"true" ]; then
                                            TMP="`echo
$line|sed 's/\ /_/g; s/_-_/_/g'`"
                                    else
                                            echo \"$line\"
>> ${0}.list             #"# <--ripristino la colorazione
per vim...
                                    fi
                                    COUNTER=2
                            else
                                    #abbiamo greppato
l'indirizzo... non ce ne facciamo niente...
                                    COUNTER=0
                            fi
                            ;;
                    2 )
                            if [ "$USEKDIALOG" == "true" ];
then
                                    echo -e "`echo ${line}|sed
s/\ /%20/g` ${TMP}" >> ${0}.list
                            else
                                    echo \"\" >>
${0}.list                          #"#
                                    echo \"$line\" >>
${0}.list                     #"# <--ripristino la colorazione
per vim...
                            fi
                            COUNTER=1
                            ;;
            esac
    done
fi

if [ ! -s ${0}.list ]; then
    echo "Canale non trovato..."
    exit 0
fi
rm ${0}.reply &>/dev/null
REPLY=""
if [ "$USEKDIALOG" == "true" ]; then
    STREAM=`kdialog --title "Rai.tv Senza Silverlight" --menu
"Lista canali disponibili" $(cat ${0}.list)`
else
    while [ -z "$REPLY" ]; do
            dialog --title "Stream disponibili" --help-button
--item-help --menu "scegli lo stream da aprire" 20 70 12 --file
${0}.list 2> ${0}.reply
            REPLY="`tail -n 1 ${0}.reply`"
            rm ${0}.reply &>/dev/null
            if [ -n "`echo $REPLY|grep '^HELP '`" ]; then
                    REPLY="`echo $REPLY|awk -F "HELP " '{print
$2}'`"       #"`" # <<-ripristino colorazione vim....
                    NAME="`grep -B 2 "$REPLY" ${0}.list|head -n
1`"
                    dialog --title "$NAME" --msgbox "Lo stream
è all'indirizzo:\n$REPLY" 20 70
                    REPLY=""
            elif [ -z "$REPLY" ]; then
                    rm ${0}.list &>/dev/null
                    break;
            fi
    done
    clear
    if [ "$REPLY" == "" ]; then
            echo "Nessuno stream trovato per questa ricerca"
            exit 0
    fi
    STREAM="`grep -A 2 "$REPLY" ${0}.list|tail -n 1|awk -F '"'
'{print $2}'`"
fi
play
rm ${0}.list   &>/dev/null
rm ${0}.canali &>/dev/null
rm ${0}.tmp    &>/dev/null
echo ""