Archivo

Archivo para la categoría ‘Bash’

Recopilación de soluciones para los retos de #tuentiContest . Challenge #12

Sábado, 25 de Junio de 2011 Gaspar Fernández 2 comentarios

Últimamente he hablado acerca del I concurso de programación de Tuenti. Un concurso de programación Online que se llevó acabo durante la semana pasada (del 13 al 20 de Junio, muy mala fecha).

Podéis ver los enunciados de todos los problemas, con ejemplos sobre la entrada y salida (aunque a veces no hay que haerles mucho caso) en la web oficial del concurso, pero en Vidas Concurrentes lo encontramos todo en español.

Challenge #12 : The Stargate Problem

Tenemos que dar saltos entre planetas. Llegar de la Tierra a Atlantis, dando saltos entre planetas a través de Stargates, cada salto tendrá un coste en tiempo, empezaremos en la fecha estelas 25000 y si podemos llegar en el pasado mejor. Eso sí, si no podemos determinar la fecha, tendremos que decir: “BAZINGA”

Soluciones:

Si no estás en la lista y quieres plantear tu solución, deja un comentario con tu link !

Actualización 2011/06/25 13:23 : Añadida solución de @enwillyado
Actualización 2011/06/28 08:30 : Añadida solución de @theom3ga
Actualización 2011/07/03 01:45 : Añadida solución de @frisco82
Actualización 2011/07/03 13:45 : Añadida solución de @Rosapolis
Actualización 2011/07/13 02:48 : Añadida solución de @lagunex

Recopilación de soluciones para los retos de #tuentiContest . Challenge #3

Miércoles, 22 de Junio de 2011 Gaspar Fernández Sin comentarios

Últimamente he hablado acerca del I concurso de programación de Tuenti. Un concurso de programación Online que se llevó acabo durante la semana pasada (del 13 al 20 de Junio, muy mala fecha).

Podéis ver los enunciados de todos los problemas, con ejemplos sobre la entrada y salida (aunque a veces no hay que haerles mucho caso) en la web oficial del concurso, pero en Vidas Concurrentes lo encontramos todo en español.

Challenge #3 :Emirps

Un emirp es un número que tanto él como su capicúa, son primos. Hay que realizar la suma de todos los emirps hasta el número especificado por stdin.

Soluciones:

Si no estás en la lista y quieres plantear tu solución, deja un comentario con tu link !

Actualización 2011/06/22 20:00 : Añadida solución de @Puigcerber
Actualización 2011/06/22 13:50 : Añadida solución de @javipinero
Actualización 2011/06/22 07:58 : Añadida solución de @theom3ga
Actualización 2011/07/02 22:32 : Añadida solución de @frisco82
Actualización 2011/07/03 13:35 : Añadida solución de @Rosapolis

Recopilación de soluciones para los retos de #tuentiContest . Challenge #2

Miércoles, 22 de Junio de 2011 Gaspar Fernández 2 comentarios

Últimamente he hablado acerca del I concurso de programación de Tuenti. Un concurso de programación Online que se llevó acabo durante la semana pasada (del 13 al 20 de Junio, muy mala fecha).

Podéis ver los enunciados de todos los problemas, con ejemplos sobre la entrada y salida (aunque a veces no hay que haerles mucho caso) en la web oficial del concurso, pero en Vidas Concurrentes lo encontramos todo en español.

Challenge #2 : TLang

Se trata de implementar un parser que suma, reste y multiplique, con los símbolos ^= ,^# 2 2 y ^@, eso sí, el final de la operación siempre lo marcará un $. Por otra parte, hay símbolos, como ^@ (resta) que pueden ir sólo con un número, en lugar de con varios. Debemos leer de la entrada las operaciones a realizar y devolver el número de salida.

Soluciones:

Si no estás en la lista y quieres plantear tu solución, deja un comentario con tu link !

Actualización: 2011/06/22 13:54 : Error tipográfico
Actualización: 2011/06/22 20:00 : Añadida solución de @Puigcerber
Actualización: 2011/06/28 07:58 : Añadida solución de @theom3ga
Actualización: 2011/07/02 22:30 : Añadida solución de @frisco82
Actualización: 2011/07/03 13:30 : Añadida solución de @Rosapolis
Actualización: 2011/07/08 12:37 : Añadida solución de captain_regex

Recopilación de soluciones para los retos de #tuentiContest . Challenge #1

Miércoles, 22 de Junio de 2011 Gaspar Fernández 5 comentarios

Últimamente he hablado acerca del I concurso de programación de Tuenti. Un concurso de programación Online que se llevó acabo durante la semana pasada (del 13 al 20 de Junio, muy mala fecha).

Podéis ver los enunciados de todos los problemas, con ejemplos sobre la entrada y salida (aunque a veces no hay que haerles mucho caso) en la web oficial del concurso, pero en Vidas Concurrentes lo encontramos todo en español.

Challenge #1 : Super Hard Sum

Recibimos por la entrada estándar una serie de números separados por espacios, y nosotros debemos sumarlos. Eso sí, a veces nos podemos encontrar muchos espacios, ceros a la izquierda o números excesivamente grandes (tipo 9999999999999999999 , diecinueve nueves, necesitamos 64bit, aunque también puede venir negativo, resultando un número de 65bit.)

Soluciones:

Si no estás en la lista y quieres plantear tu solución, deja un comentario con tu link !

Actualización: 2011/06/22 11:45 : Añadidas soluciones de Rodrigo Díaz
Actualización: 2011/06/22 13:20 : Arreglada la autoría de las soluciones de @brok3r. Link a @manufloresv
Actualización: 2011/06/22 19:45 : Añadida solución en ensamblador por ThD
Actualización: 2011/06/22 20:00 : Añadida solución de @Puigcerber
Actualización: 2011/06/24 11:35 : Añadida mi solución.
Actualización: 2011/06/27 22:30 : Añadida solución de @theom3ga
Actualización: 2011/07/02 22:30 : Añadida solución de @frisco82
Actualización: 2011/07/03 13:30 : Añadida solución de @Rosapolis

Finalizó el Tuenti Contest, ¿qué os pareció?

Miércoles, 22 de Junio de 2011 Gaspar Fernández Sin comentarios

img

Empezó siendo un comentario de mi novia, ya que al entrar en Tuenti, unos días antes de que se llevara a cabo aparecía al entrar, y yo, que como veis me encanta este mundo, me apunté. Al principio fue con la intención de coger ejemplos para las clases particulares, que muchas veces me encuentro con alguna duda puntual de un alumno y me quedo sin ejemplos.

Lo que pretendía, ingenuo de mí, era saltarme todos o casi todos los retos, copiar las preguntas y los resultados, para hacerlos tranquilamente en cuanto tuviera algo más de tiempo. Ya investigaría si me viene un algoritmo raro y los desarrollaría tranquilamente para este blog.

Por parte de la organización del concurso se facilitaban una serie de programas para probar los programas realizados y para enviarlos, es normal que poner espacios de más o textos que no son exactos a la solución esperada sean rechazados, es un sistema automático, esto ha sido una de las quejas que he visto por ahí, es verdad que podrían haber hecho un trim() para los espacios del final, pero bueno, nos lo han dejado a nosotros. Además, una vez subías una respuesta o te saltabas un reto, no había vuelta atrás.

Pero cuando el día antes de empezar publican un ejercicio de prueba de “lo que íbamos a encontrarnos”, me puse a hacerlo durante el desayuno, me pareció muy curioso lo que planteaban, me gustó la sensación al ver los OK! al probar mi código.

Al día siguiente, entré para ver cómo era todo, para no hacer muchos retos y bajarme contenidos, pero vi el segundo, y me puse a hacerlo, aunque desde el punto de vista de un profesor de programación, intentando utilizar órdenes básicas y que no asusten mucho a estudiantes y en C, y así el tercero, y el cuarto, y cuando menos me lo esperaba me di cuenta de que llevaba 7 retos hechos y tenía que dejarlo durante un rato.

Pero bueno, más allá del pique que me produjo el desarrollo de los problemas encontré varios inconvenientes:

  • Las pruebas que proponían en la página web del concurso no se parecían en nada a las pruebas de la fase de test y éstas tampoco se parecían a las pruebas que se realizaban a la hora de subir el código, cada vez eran pruebas más duras, y algún programa que hice aunque superó la prueba del test, no superó la prueba al subir.
  • Cada vez explicaban menos qué había que hacer y las pruebas propuestas eran incompletas o erróneas, lo cual dificultaba un poco la realización de los retos, aunque sí, por otra parte, agudizaba nuestro pensamiento ingeniero.
  • La comunicación por parte del usuario de Twitter de Tuenti (@TuentiEng) era más bien poca. Aunque comprendo que tampoco se puede contestar a todo y a todos.
  • Los últimos retos eran frustrantes, en el 17, por ejemplo, sólo decía “Just do it” e imposibles, bueno, no tanto, porque hay personas que los superaron.

Un detalle curioso es que la comunicación por parte de Tuenti se hacía a través de Twitter y, aunque puede parecer contradictorio, yo creo que tiene toda la lógica del mundo, hay más personas con Twitter que con Tuenti, y por Twitter la comunicación es más fluida, aunque también había un muro en la red social organizadora pero no tenía ni la décima parte de actividad.

Por último me gustaría felicitar a todos aquellos que habéis completado el concurso (yo me quedé por el 20, aunque el 19 no me terminó de salir bien, lo mio no es la criptografía, aunque poco a poco iré aprendiendo) y destacar aspectos muy positivos de este concurso:

  • He aprendido cosas muy interesantes, nos piden implementar problemas que no se suelen implementar en una carrera universitaria, y si se han llegado a implementar, las pruebas que debían pasar los algoritmos, no son tan duras en muchos casos.
  • Tengo una comunidad en Twitter más amplia con nuevos contactos muy interesantes, sobre todo de participantes.
  • La experiencia ha sido muy positiva. Participé activamente en el concurso y eso que sólo iba a seguirlo por encima para copiar los enunciados.

Actualización: Una cosa más, estoy preparando un post recopilatorio con todas las soluciones que encuentre.

Limitando recursos en ImageMagick

Jueves, 21 de Abril de 2011 Gaspar Fernández 2 comentarios

A veces, utilizar ImageMagick puede ser horrible, sobre todo porque en ocasiones, se come todos los recursos de nuestro sistema, al procesar imágenes grandes, múltiples imágenes, vídeo, etc… en ocasiones puede que el OOM Killer de Linux detenga la tarea, y puede que mientras procesamos las imágenes, necesitemos el ordenador para algo.

NOTA: Utilizaré convert para poner ejemplos de cómo utilizar esta herramienta, pero estos consejos valen para todos los programas de tratamiento de imagen que componen imagemagick: convert, mogrify, montage…

Bien, ImageMagick tiene opciones para modificar cuánta memoria va a acaparar. Si sabemos que es una tarea muy pesada para la memoria (una imagen de 5000×5000 ocupará cerca de 70Mb, una imagen de 10000×10000 cerca de 300Mb, sin contar la memoria utilizada para el tratamiento de la imagen) podemos decir a ImageMagick que utilice como mucho 20Mb de RAM (el resto de memoria que necesite la cogerá del disco duro, de nuestro directorio temporal).
Para esto, podemos utilizar lo siguiente:

$ convert imagenA.jpg -limit memory 20MiB -resize 50% imagenB.png

Si durante el proceso, ejecutamos top podremos ver la diferencia de memoria utilizada.
Podemos ver los recursos que podemos limitar con:

$ identify -list resource
File Area Memory Map Disk Thread Time
——————————————————————————-
768 4.2324GB 2.9563GiB 7.8835GiB 18.446744EB 1 unlimited

Las peticiones de memoria que hace ImageMagick como vemos aquí son las siguientes:
Se intenta reservar memoria para los pixels, pero si la memoria excede el límite de memory, o falla (puede que el sistema no disponga de memoria suficiente), lo escribirá en disco y lo mapeará en memoria, pero si se excede la memoria del mapa de memoria, todo va a disco, si ya no tenemos disco duro suficiente, o hemos limitado el disco disponible fallará.
Tenemos que tener en cuenta que hacemos distinción entre MiB (MebiBytes) (1MiB=1.048.576 bytes) y MB (MegaByte) (1MB = 1.000.000 bytes)

Así que también podemos limitar la memoria de los mapas de memoria, de disco, los threads a utilizar (o podemos darle más, si queremos), por ejemplo, si queremos insertar imágenes en un pdf:

$ convert *.jpg -limit memory 200MiB -limit map 200MiB resultado.pdf

También es muy útil el parámetro de area, este vale para limitar la memoria de forma absoluta, es decir, para que ImageMagick no intente hacer nada en memoria si excedemos esta cantidad de memoria (a veces es mejor limitar la memoria, antes de que intente encajar las reservas de memoria en los otros dos parámetros, y tenemos más control sobre la memoria utilizada):

$ convert *.jpg -limit area 300M resultado.pdf

Todas estas opciones de ImageMagick pueden ser variables de entorno: MAGICK_AREA_LIMIT, MAGICK_DISK_LIMIT, MAGICK_FILE_LIMIT, MAGICK_MEMORY_LIMIT, MAGICK_MAP_LIMIT, MAGICK_THREAD_LIMIT, MAGICK_TIME_LIMIT. Podemos hacer lo siguiente para ver que los cambios se aplican correctamente:

$ export MAGICK_AREA_LIMIT=50M
$ export MAGICK_MEMORY_LIMIT=10MiB
$ export MAGICK_MAP_LIMIT=30MiB
$ convert -list resource
File Area Memory Map Disk Thread Time
——————————————————————————-
768 50MB 10MiB 30MiB 18.446744EB 1 unlimited

Como habréis podido comprobar, también se puede limitar por tiempo, incluyendo -limit time [segundos] o con la variable de entorno MAGICK_TIME_LIMIT.

Pero no acaba aquí, podemos hacer que el procesado de imagen sea un poco más lento, pero nos deje el ordenador libre para otros usos, esto es con la variable de entorno MAGICK_THROTTLE, ImageMagick periodicamente dejará respirar el procesador tantos milisegundos como le hayamos asignado a la variable:

export MAGICK_THROTTLE=100

Dejará de procesar 100ms en varias ocasiones durante el proceso, lo podremos usar si vemos que el proceso será largo, no nos importa la velocidada y va a utilizar toda nuestra CPU.

También podemos acompañar todas estas opciones de ImageMagick con nice e ionice. Por ejemplo, con ionice podremos retrasar o priorizar los accesos a disco y con nice la prioridad del proceso. Si de verdad no nos importa cuánto tarde la conversión podemos hacer lo siguiente:

nice -n 20 ionice -c3 convert *.jpg -limit area 200M resultado.pdf

Con lo que asignaremos la menor prioridad al proceso, y además sólo accederá a disco cuando nadie más lo haga (si otro proceso quiere escribir en disco, convert tendrá que esperar)

Now playing… para mplayer

Domingo, 14 de Noviembre de 2010 Gaspar Fernández Sin comentarios

screenshot-14-11-2010-201150Se trata de un script para bash que representará en pantalla información del archivo que se está reproduciendo al mismo tiempo que este se visualiza. Perfecto para un sistema mediacenter.

Requerimientos:

  • bash >=3.0
  • mplayer
  • xosd
  • utilidades de sistema utilizadas: date, sed, tr, cut, sleep

Entre sus características destaca la escritura de un archivo: $HOME/.videolog con los archivos que se reproducen. Uno de los posibles usos es la descarga de muchos vídeos de youtube en un directorio concreto, posterior visualización y borrado de cada uno de los archivos tras su visionado.

Además, si el archivo de audio o vídeo a reproducir contiene metadatos de Artista y Título, se visualizará la información de estos metadatos siempre que no estén en la lista negra (variable $ARTISTAS_PROHIBIDOS), en otro caso visualizaremos el nombre del archivo arreglado (eliminando las cadenas que aparecen en la variable FILENAME_RECORTADO, aquí podemos incluir extensiones o pequeñas anotaciones sobre la calidad o resolución de un vídeo).

Se recomienda modificar XOSD_OPTIONS_ARTISTA, XOSD_OPTIONS_TITULO, XOSD_OPTIONS_INFO y XOSD_OPTIONS_DURACION de acuerdo a los tipos de letra, colores y todo lo que se desee. Dejo una pequeña referencia de las opciones de osd_cat:

–pos Posición del texto: top(arriba), middle(en medio de la pantalla), bottom(abajo)
-A Alineación del texto: left(izquierda), center(centrado), right(derecha)
-c Color: puede ser en notación html #rrggbb o por su nombre
-s Offset o desplazamiento de la sombra
-o Offset o desplazamiento desde la parte superior o inferior de la pantalla
-d Tiempo en segundos que se mantendrá el texto en la pantalla
-f Tipo de letra. Para ver los tipos de letra disponibles ejecutar xfontsel.

Inicio del archivo: mplayernp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
#!/bin/bash

##########################################################################
#
# MPLAYER NOW PLAYING version 0.1
# Copyright (C) 2010 by Gaspar Fernández <gaspy at totaki.com>
# http://totaki.com/poesiabinaria
#
##########################################################################

#   This program is free software: you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation, either version 3 of the License.

#   This program is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.

#   You should have received a copy of the GNU General Public License
#   along with this program.  If not, see <http://www.gnu.org/licenses/>.

XOSD_OPTIONS_ARTISTA="--pos=bottom -A left -c #fff -o -110 -s 2 -d 10 -f -*-utopia-*-*-*-*-*-520-*-*-*-*-*-*"
XOSD_OPTIONS_TITULO="--pos=bottom -A left -c #fff -o -100 -s 2 -d 10 -f -*-utopia-*-*-*-*-*-420-*-*-*-*-*-*"
XOSD_OPTIONS_INFO="--pos=bottom -A left -c #fff -s 2 -o -80 -d 10 -f -*-utopia-*-*-*-*-*-320-*-*-*-*-*-*"
XOSD_OPTIONS_DURACION="--pos=bottom -A left -c #fff -s 2 -o -60 -d 10 -f -*-utopia-*-*-*-*-*-220-*-*-*-*-*-*"

# Si precalculamos esto, damos velocidad
ESCAPE=`echo -e "\e"`

ARTISTAS_PROHIBIDOS=("virtualdub")
FILENAME_RECORTADO=(".avi" ".flv" ".mp3" ".mp4")

function print_info()
{
    artist="$1"
    title="$2"
    filename="$3"
    width="$4"
    height="$5"
    fps="$6"
    minutos="${7/./,}"      # Si nuestra locale es es_ES debemos sustituir puntos por comas
    segundos="${8/./,}"
    if [[ -n $artist ]]
    then
    artist_text=${info_val[$artist]}
    for proh in ${ARTISTAS_PROHIBIDOS[*]}
    do
        if [[ `echo $artist_text | tr [:upper:] [:lower:]` =~ $proh ]]
        then
        artist="";
        title="";
        break;
        fi
    done
    fi

    if [[ -n $artist ]]
    then
    echo $artist_text | osd_cat $XOSD_OPTIONS_ARTISTA &
    fi
    if [[ -n $title ]]
    then
    title_text=${info_val[$title]}
    echo $title_text | osd_cat $XOSD_OPTIONS_TITULO &
    else
    # Si no tenemos la codificación correcta configurada, esto puede saltar
#   fname=`basename "$filename"`
#   dname=`dirname "$filename"`
#   defname=`ls "$dname/$fname"*`
#   defname=`basename "$defname"`
    defname=`basename "$filename"`
    for recorte in ${FILENAME_RECORTADO[*]}
    do
        defname=${defname/$recorte/}
    done
    echo $defname | osd_cat $XOSD_OPTIONS_TITULO &
    fi
    if [[ -n $fps ]]
    then
    echo $width"x"$height"@"$fps | osd_cat $XOSD_OPTIONS_INFO &
    fi
    duracion=`printf "%1.0f:%1.0f" "$minutos" "$segundos"`
    echo $duracion | osd_cat $XOSD_OPTIONS_DURACION &

    echo "`date +"%d/%m/%Y %H:%M"` Media: $filename Dur: $duracion" >> $HOME/.videolog

}

function keyvalue()
{
    key=`echo "$1" | cut -d= -f1`
    value=`echo "$1" | cut -d= -f2`

    res[0]=$key;
    if [[ -n $value ]]
    then
    res[1]=$value;
    else
    res[1]="0";
    fi

    if [[ -n `echo $key | grep "ID_CLIP_INFO_NAME\|ID_CLIP_INFO_VALUE"` ]]
    then
    # Si tenemos un ID_CLIP_INFO_NAMEx o ID_CLIP_INFO_VALUEx extraemos el x
    info=(`echo $key | sed -n -e "s/\([a-zA-Z_]*\)\([0-9]*\)/\1\n\2/p"`)
   
    res[0]=${info[0]}
    res[2]=${info[1]}
    fi
    echo -e ${res[0]}"\n"${res[1]}"\n"${res[2]}"\n"


}

function tituladora()
{

artist="";
title="";
while read -n 200 dato 
do
    if [[ -n `echo $dato | grep ID_` ]] # Extraemos información de mplayer
    then
    OLD_IFS=$IFS;
    IFS="
"
;
    kval=( `keyvalue $dato` );
#   echo ${kval[0]} "********"
    IFS=$OLD_IFS

    case ${kval[0]} in
        "ID_FILENAME")
        filename="${kval[1]}"          
        ;;
        "ID_VIDEO_WIDTH")
        width=${kval[1]}
        ;;
        "ID_VIDEO_HEIGHT")
        height=${kval[1]}
        ;;
        "ID_VIDEO_FPS")
        fps=${kval[1]}
        ;;
        "ID_LENGTH")
        seconds=${kval[1]};
        # Extrae la duración en minutos y segundos
        duration=( `echo "scale=0; $seconds / 60; scale=0; $seconds % 60" | bc` )
        ;;
        "ID_CLIP_INFO_NAME")
        if [[ `echo ${kval[1]} | tr [:upper:] [:lower:]` == "artist" ]]
            then
#           echo "ARTISTA CAPTURADO "${kval[2]};
            artist=${kval[2]} # Donde encontramos el artista
        else
            if [[ `echo ${kval[1]} | tr [:upper:] [:lower:]` == "title" ]]
            then
            title=${kval[2]} # Donde encontramos el artista
#           echo "TITULO CAPTURADO"
            fi
        fi
        ;;
        "ID_CLIP_INFO_VALUE")
        # Almacenamos el valor obtenido
#       echo "ALMACENO EN "${kval[2]} "ESTO" ${kval[1]} "**" ${kval[0]} ${kval[2]} = ${kval[1]}
        info_val[${kval[2]}]="${kval[1]}"
        ;;
    esac
#   echo ${info_val[@]}
    else
    # Si encontramos caracteres de control....
    if [[ $dato =~ $ESCAPE ]]
    then

        # Tal vez podamos comentar esto para dar velocidad --- INICIO
        if [[ $dato =~ "Position" ]]
        then       
        printf "%s\n" "$dato"
        else
        printf "%s" "$dato"
        fi
        # Tal vez podamos comentar esto para dar velocidad --- INICIO
    else
        if [[ ${dato:0:3} == "AO:" ]] # Aquí empieza el Audio... saltaremos tanto para archivos de audio como
                                      # para vídeos / películas... que también tengan audio
        then
        # Empieza la reproducción
        sleep 1 && print_info "$artist" "$title" "$filename" "$width" "$height" "$fps" "${duration[0]}" "${duration[1]}"
        fi

        echo $dato;
    fi
    fi
done
}
mplayer -identify $@ | tituladora

Por último, para utilizar este programa, podemos crear un alias a mplayer:

alias mplayer=”mplayernp”

Para finalizar dejo algúnos ejemplo de uso (son válidos también para mplayer, ya que mplayernp pasa los comandos tal cual a mplayer:

1
2
# Para reproducir archivos dentro de un directorio con orden aleatorio y en pantalla completa
mplayernp -fs `ls /directorio/*.avi | sort -R`

Vídeo de la foto: El Hombre de Negro - Greenfield

Intercambiar mensajes en red local [ solución rápida con netcat y kdialog ]

Sábado, 23 de Octubre de 2010 Gaspar Fernández Sin comentarios

A veces tenemos la necesidad de, en la propia red local intercambiar algún mensaje de texto, ya sea una dirección web o algo así. Muchas veces se opta por enviar un e-mail, aunque aquí traigo una propuesta interesante. No para uso diario, pero para uso puntual cuando no tenemos nada a mano, o para estudiar el método.

Actualmente usa netcat y KDE (para la petición de datos de forma gráfica).

Con netcat sólo bastaría. En un ordenador ponemos:

$ netcat -l -p 6517

Actuaría como servidor escuchando por el puerto 6517 (he usado este puerto, porque creo que no hay ningún servicio definido en este lugar), luego en otro ordenador podemos escribir:

$ netcat [IP/host del primer ordenador] 6517

Con lo que conectaríamos con el otro ordenador. Es una conexión no cifrada, con lo que en este punto no estamos hablando de seguridad, sólo de un “apaño”.

Pero bueno, aunque sea un apaño no tiene por qué ser demasiado feo, así que vamos a acompañarlo de unos diálogos (con kdialog) y a hacer unos scripts que nos permitan iniciar netcat de forma fácil (incluso vincularlo a una tecla de nuestro sistema).

[ enviamensaje ]

1
2
3
4
5
host=`kdialog --inputbox "A que host quieres enviar un mensaje"`
mensaje=`kdialog --inputbox "Escribe el mensaje"`

# Puerto 6517 sin asignar
echo "$mensaje" | netcat -c $host 6517

Desde este archivo preguntamos al usuario el host con el que quiere hablar, y luego se le pide introducir el mensaje, que se mandará por netcat ( -c vale para que la conexión se cierre cuando se termine de enviar el mensaje )

[ recibemensaje ]

1
2
3
4
5
6
7
8
9
10
while read input
do
        kdialog --textinputbox "Alguien te manda algo" "$input" 2>&1 1>/dev/null;
        if [[ "$?" != "0" ]]
        then
                break;
        fi
done

echo "FIN DEL PROGRAMA"

Con este script escribiremos en un diálogo con kdialog el texto recibido por el mensaje. netcat nos pasará por su salida estándar el contenido del mensaje, así que tendremos que leerlo con read

Si aceptamos la ventana dejaremos de esperar mensajes.

[ servidormensajes ]

1
2
3
4
5
6
7
8
9
while (( 1 ))
do
        netcat -l -p 6517 -e ./recibemensaje
        kdialog --yesno "Desconectar servidor?"
        if [[ "$?" == "0" ]]
        then
                break;
        fi
done

Desde aquí ponemos el socket en escucha ( -l = listen ) en el puerto 6517 y lo que recibamos se lo pasamos al script recibemensaje; una vez que esto termine nos preguntará si queremos cerrar el servidor o estamos esperando mensajes de alguien más.

Ahora sólo tenemos que vincular a alguna tecla los script servidormensajes y enviamensaje con lo que podremos comunicarnos con las personas de nuestra red local sin problema. El programa también funcionará por Internet, si tenemos los puertos necesarios abiertos y redireccionados en el router (si usamos router) o nuestro firewall no restringe las conexiones por el puerto 6517 (aunque podemos cambiarlo).

Vídeo digital: Secuencias de imágenes

Jueves, 16 de Septiembre de 2010 Gaspar Fernández Sin comentarios

Esta vez voy a presentar algunos ejemplos de uso de ffmpeg con secuencias de imágenes. Para empezar a trabajar con vídeo digital desde GNU/Linux.

Crear vídeo a partir de una secuencia de imágenes

Es una buena técnica el hecho de trabajar con secuencias de imágenes para crear un vídeo. Podemos, por ejemplo utilizar la potencia de Imagemagick (I, II, III, IV) para modificar el color de la imagen, etiquetarlas o darle algún tratamiento. O incluso para manejar transparencias en vídeo de una forma controlada. Para las secuencias de imágenes es conveniente utilizar un formato de imagen sin pérdidas como png, pnm, o jpg sin pérdidas (ojo, no jpg normal).

Para hacer la conversión podemos utilizar esta orden:

$ ffmpeg -f image2 -i directorio/imag%d.png -r 25 -vcodec mpeg4 video.avi

Elegimos como entrada un formato de imágenes y las exportaremos a 25 fps, con el codec mpeg4 y el archivo se llamará video.avi. Todas las imágenes estarán dentro de directorio y se llamarán imag0.png, imag1.png, imag2.png, …

Siempre depende el codec que vayamos a utilizar, si queremos enviarlo por Internet, o grabarlo en algún soporte como montaje definitivo podemos utilizar el formato mpeg4, theora, h264, vp8, etc; si queremos grabarlo en DVD podemos escoger mpeg2, aunque si vamos a utilizarlo como parte de nuestro proceso de montaje podemos usar dv o algún codec sin pérdidas como ljpeg, jpegls, v210, etc; el objetivo, para montaje es utilizar un formato sin comprimir o comprimido sin pérdidas.

Creando un vídeo sólo con una imagen

En ocasiones, puede ser necesario crear un archivo de vídeo que sólo contenga una imagen. ¿ Por qué ? Podemos crear algún script que haga algún efecto con ese vídeo, una transición, o podemos unirlo a un vídeo, para hacer de cortinilla de inicio o cierre.

Para ello hacemos lo siguiente:

$ ffmpeg -loop_input -f image2 -i imagen.png -vframes 50 -r 10 -vcodec libtheora video.avi

Donde grabaremos 50 frames con la imagen imagen.png a 10 fotogramas por segundo y con el codec theora. Aunque, en lugar de especificar los fps podemos especificar el tiempo que queremos que dure (en hh:mm:ss.[xxx], es decir, horas, minutos, seguntos, centésimas):

$ ffmpeg -loop_input -f image2 -i imagen.png -t 00:00:5.50 -r 10 -vcodec libtheora video.avi

Donde grabaremos un vídeo de 5 segundos y medio con la misma imagen.

Pasando un vídeo a secuencia de imágenes

Ahora tratamos de hacer la primera conversión, de vídeo a imágenes, intentando escoger el codec adecuado. Aunque podemos utilizar jpg, vamos a exportar a png para dar más calidad a las imágenes:

$ ffmpeg -i video.avi -f image2 -vcodec png video/frame_%d.png

Grabaremos los distintos fotogramas del video (video.avi) en el directorio video y con archivos llamados frame_1.png, frame_2.png, frame_3.png…

Jugando con ImageMagick (IV): Automatizando procesos, creando animaciones

Martes, 14 de Septiembre de 2010 Gaspar Fernández 3 comentarios

El cuarto post de la serie, anteriormente hablábamos de:

  1. Dimensiones, Captura, Color y Efectos
  2. Color (continuación) y Rotación
  3. Jugando con ImageMagick (III): Colecciones, texto, y unión de efectos

Ya que estamos hartos de ver lo que es capaz de hacer ImageMagick, ahora mezclemos esto con la potencia de la consola, y tendremos una de las herramientas más potentes jamás inventadas en cuanto a imagen digital se refiere.

Modificando imágenes en un directorio

Aunque podremos hacer cualquier tipo de modificación, tal y como hemos visto anteriormente, haremos un ejemplo en el que redimensionaremos todos los archivos de un directorio al 50% (muy útil si preparamos en un directorio muchos archivos directamente de una cámara digital para subir a Internet):

$ mogrify -resize 50% directorio/*

Con mogrify podemos hacer lo mismo que con convert, sólo que el fichero de origen y de destino es el mismo.

Aunque… ¿y si queremos guardar los archivos originales? Tendremos que hacer un pequeño script para convertir los archivos de un directorio y guardarlos en otro direcorio diferente; pero… y si son muchos ? Tenemos algunas posibilidades:

$ for f in test/*.jpg; do convert -monitor -resize 50% $f “test2/”${f##*/}; done

Si tenemos todos los archivos en el directorio test, queremos redimensionar al 50% y guardarlos en test2/ con el mismo nombre que tienen. ${f##*/} elimina el directorio del nombre del archivo, es lo mismo que la orden basename. Y con el parámetro -monitor veremos más o menos lo que está haciendo convert en cada momento.

Aunque, tal vez queramos un indicador de progreso para saber más o menos cuánto queda y cuántos archivos llevamos, lo podemos hacer con bc y Xdialog:

1
2
3
4
5
6
7
8
9
archivos=`ls test/*.jpg`;
total=`echo $archivos | wc -w`;
hecho=0;
for f in $archivos;
do
convert -resize 50% $f "test2/"${f##*/};
let hecho=$hecho+1;
echo "scale=0;$hecho*100/$total"|bc;
done | Xdialog --gauge "Progreso..." 10 100 0

En este ejemplo, separamos en variables los archivos a tratar y contamos el total de archivos a procesar. La variable hecho contará cuántos archivos ha convertido hasta el momento.

Luego en el bucle principal convertiremos los archivos e iremos incrementando la variable hecho en 1. Más adelante, con la ayuda de bc calculamos el porcentaje hecho. El bucle lo pasamos con una pipe a Xdialog, con su opción de gauge con lo que iremos indicando el proceso a medida que se vayan convirtiendo archivos.

Añadiendo un texto a todas las imágenes

Podemos, además, añadir un texto a todas las imágenes con un formato determinado para incluir el nombre de fichero, ancho, alto, la etiqueta de fichero, etc:

$ mogrify -gravity South -pointsize 20 -fill black -annotate ‘%f %b bytes” *

Con lo que anotaremos dentro de la imagen en color negro el nombre del archivo y el tamaño en bytes. Para esto tenemos algunas palabras clave como %f y %b en este enlace: Imagemagick.org (Identify -format).

hamburguesonAunque tal vez queramos poner un texto diferente a cada foto. Imaginemos que tenemos muchos ficheros jpg y muchos ficheros txt. Los ficheros txt tienen el mismo nombre que los jpg y sólo varía la extensión; y queremos plasmar el texto de los txt en los ficheros jpg:

1
2
3
4
5
6
7
8
9
10
11
for f in *.jpg;
do
if [ -r ${f%.*}.txt ];
then
txt=`cat ${f%.*}.txt`;
else
txt="Mis guisos 2010";
fi;
echo $txt en $f;
mogrify -gravity North -pointsize 15 -fill white -annotate 0x0+10+10 "$txt" $f;
done

Esta vez, si encontramos el fichero de texto con el mismo nombre que la imagen, solo que con extension txt escribiremos ese texto en la parte superior de la imagen; pero si no, escribiremos “Mis guisos 2010″ y así recorriendo todos los archivos jpg del directorio.

Una animación sencilla

destinVamos a crear una transición entre dos imágenes. Y para el ejemplo, hemos utilizado estas dos imágenes:

$ convert -size 720×576 xc:black -gravity Center -fill white -pointsize 250 -font impact -draw ‘text 0 0 A’ a.jpg

$ convert -size 720×576 xc:black -gravity Center -fill white -pointsize 250 -font impact -draw ‘text 0 0 B’ b.jpg

Para realizar el fundido hacemos lo siguiente:

1
2
3
4
5
6
7
8
9
10
11
12
13
n_imgs=30; # Número de imágenes
s=`echo "scale=2;100/$n_imgs" | bc` # Porcentaje de inremento de cada paso.
o=0;   # Visibilidad de la imagen B
d=100; # Visibilidad de la imagen A
f=0;   # Fotograma actual
while (( $f &lt; 20 ));
do
convert -compose blend -set "option:compose:args" $o,$d a.jpg b.jpg -composite dest/anim_$f.jpg;
o=`echo "scale=2;$o+$s" | bc`;
d=`echo "scale=2;$d-$s" | bc`;
f=$(($f+1));
echo "Frame: $f O=$o D=$d";
done

Con esto se creará la secuencia de $n_imgs (que al principio le damos valor 30) imágenes en el directorio dest/; todas empezando por anim_.

Si queremos crear un gif animado con esto, podemos hacer lo siguiente:

$ convert dest/anim_{0..29}.jpg trans.gif

Visita otras webs de la red