Imprimir desde Android

Pues es muy difícil.
Se nota que está pensado para teléfonos: lo único oficial que he encontrado que soporta el sistema operativo es una API miserable para imprimir sólo texto.
Me recuerda los tiempos antiguos del MS-DOS: las aplicaciones gestionan directamente la impresión, normalmente respondiendo a las acciones "share" o "view". Así que, no habiendo API oficial, exigen partir de formatos conocidos: PDF, imágenes, o documentos de MS Office.

En lugar de arreglar la API para poder usar Bluetooth, o los USB, para conectarse directamente con tu impresora, las fuerzas mayores proponen matar moscas a cañonazos: enviar por HTTPS o correo los documentos a Internet y que llegen a la impresora que tienes al lado (Google Print Cloud, HP ePrint).

Hay otras soluciones (de pago):
- PrinterShare Puede usar Wifi o bluetooth si la impresora los soporta. Acepta DOC, DOCX, XLS, XLSX, PPT, PPTX, PDF, TXT. 

Otros enlaces interesantes:
PrintIntent API
CUPS
HPLIP Android PDF Viewer basado en MuPDF library

Velocidad de conversión de vídeo DV a DVD

Una sencilla comparativa de velocidad: partir de un fichero de vídeo DV, convertirlo a DVD PAL, y anotar los fotogramas por segundo que nos reporta ffmpeg.

ffmpeg -threads 2 -i a.dv -target pal-dvd -y a.vob

Para exprimir nuestro procesador al máximo, hay que compilar ffmpeg con las optimizaciones de nuestra arquitectura (usar --cpu= en configure), y hay que ejecutarlo con tantas "threads" como núcleos tengamos.

Tengo bastante variedad de CPUs a mi alcance, e iré completando esta tabla:

Fotogramas por segundo

CPU	GHz	cache K	--cpu=	-threads 1	-threads 2	-threads 3	-threads 4
Pentium-M	1.40	1024	pentium-m	38	-	-	-
Amd Neo K125	1.70	1024	amdfam10	42	42	-	-
Intel D830	3.00	2048	prescott	41	65	-	-
Intel E6400	2.13	2048	core2	85	119	-	-
E2-1800	1.70	1024	amdfam10	100	116	-	-
E2-1800	1.70	1024	amdfam10 64b	109	122	-	-
Intel E5200	2.50	2048	core2	89	129	-	-
Intel E5200	2.50	2048	core2 64b	109	138	-	-
Intel Q8300	2.50	4096	core2	103	133	158	132
Intel Z3775	1.46	2048	core2	110	134	152	159
Intel i7 640LM	2.13	4096	core2	86	118	142	160
Intel i3 3217U	1.80	3072	core2 64b	165	196	222	226
Intel i7 640LM	2.13	4096	corei7	199	245	281	290
Intel i7 640LM	2.13	4096	corei7 64b	216	267	298	310
i5-3450	3.10	6144	corei7	200	275	327	351
i5-3450	3.10	6144	corei7 64b	215	299	364	389
Intel i7 3630QM	2.40	6144	corei7 64b	217	311	394	413
Intel i5 8300H	2.30	8192	corei7 64b	518	883	1118	1098

Sorprenden los resultados de mi humilde Pentium-M. La posible explicación es que está corriendo sobre Ubuntu, y este test debe estar limitado por el ancho de banda del disco (los demás procesadores corren sobre Cygwin).

También es curioso que el Q8300 y el 8300H funcionen mejor con 3 threads que con 4. Posible caso de cache trashing.

Recortar y rellenar con FFMpeg

Vamos a usar los filtros crop y pad.

Para recortar a una imagen 8 píxeles por la izquierda, y 8 por la derecha:

ffmpeg.exe -i input.png -vf 'crop=in_w-16' output.png


Para rellenar con verde (R=69,G=94,B=18) 4 píxeles por la izquierda, y 4 por la derecha, si la imagen tiene 142 de ancho:

ffmpeg -i input.png -vf 'pad=150:0:8:0:699418' output.png

El filtro crop permite referenciar variables que representan el ancho/alto de la imagen. El filtro crop todavía no admite variables.

Crear imágenes monocromas con FFMpeg

Al pensar en FFmpeg como el mejor conversor de multimedia, nos solemos olvidar de que, aparte de vídeo y audio, también maneja imágenes.

En los sistemas Unix tenemos /dev/zero que es una fuente de ceros. Sólo tenemos que darle un tamaño, y una profundidad de bits para tener una imagen de color negro:

# Black image bgra PNG
ffmpeg -vframes 1 -s 64x32 -pix_fmt rgb32 -f rawvideo -i /dev/zero -pix_fmt rgb32 black64x32.png
# Black image rgb PNG
ffmpeg -vframes 1 -s 64x32 -pix_fmt rgb24 -f rawvideo -i /dev/zero -pix_fmt rgb24 black64x32.png

Si queremos otros colores, la cosa se complica: hay que usar filtros (lo cual implica un ffmpeg muy reciente). Los pasos son leer cualquier imagen de partida, superponer el generador de colores, y escalar al tamaño deseado:

# Gray image 50% transparent
ffmpeg -i black64x32.png -vf 'color=gray@.5:64x32:25 [over]; [in][over] overlay [out]' -vf scale=640:200:rgba -pix_fmt rgb32 gray640x200.png
# Gray image
ffmpeg -i black64x32.png -vf 'color=gray:64x32:25 [over]; [in][over] overlay [out]' -vf scale=640:200:rgb24 -pix_fmt rgb24 gray640x200.png

Recordad que, de todos los formatos de píxels que muestra ffmpeg -pix_fmts, sólo rgb32 y yuva420p permiten transparencia.

Compilar frei0r para Windows desde Cygwin

Vamos a compilar "fuera del árbol de código". Así podemos tener un directorio para cada compilación (uno para Cygwin, otro para MinGW32, otro para MinGW64)
mkdir frei0r-mingw32; cd frei0r-mingw32

Queremos compilación cruzada (de Cygwin a MingGW32), así que hay que especificar a CMake el compilador que queremos, dónde están los includes/libs de MinGW32, y dónde queremos instalar los binarios resultantes. El último parámetro es dónde está nuestro código fuente.

Creamos los "makefiles"
CFLAGS=-march=core2 cmake \
-D CMAKE_HOST_SYSTEM_NAME=Unix \
-D CMAKE_SYSTEM_NAME=Windows \
-D CMAKE_C_COMPILER=/usr/bin/i686-w64-mingw32-gcc.exe \
-D CMAKE_CXX_COMPILER=/usr/bin/i686-w64-mingw32-g++.exe \
-D CMAKE_FIND_ROOT_PATH=/usr/i686-w64-mingw32/sys-root/mingw/ \
-D CMAKE_INSTALL_PREFIX=/usr/i686-w64-mingw32/sys-root/mingw/ \
../frei0r-plugins-1.2/

Compilamos
make

Dejamos los módulos mondos y lirondos
/usr/bin/i686-w64-mingw32-strip src/*/*/*.dll

Instalamos
make install

Copiamos el include
cp -p ../frei0r-plugins-1.2/include/frei0r.h /usr/i686-w64-mingw32/sys-root/mingw/include

Comprimir PNG: pngnq y pngcrush

Las fotos se suelen guardar en JPEG porque ocupan menos que en PNG. Pero si queremos transparencia, hay que usar PNG.

Podemos usar un requantizador, pngnq, que pase de ARGB de 32 bits por píxel a un formato de paleta de 256 colores, con 8 bits por píxel.

Y después intentar buscar cuál de los variados algoritmos de zlib compactan mejor el PNG, con pngcrush.

Todo junto queda:
pngnq -n 256 imagen.png && pngcrush -brute imagen-nq8.png imagen_final.png

El soporte para la Intel 855GM va a peor en Ubuntu

Mi portátil empezó su singladura en Ubuntu en 8.04. Todo se instaló sin problemas.
La actualización a 8.10 transcurrió sin novedad. Tras modernizarme a 9.10, la aceleración de vídeo dejó de funcionar.

Acabo de actualizar a 10.04, y el soporte para mi tarjeta gráfica ha ido todavía, a peor: ni siquiera arranca.

Sí, hay ñapas para sobrevivir a ambos fallos, pero la gente instala Ubuntu por su facilidad de uso, es muy  raro que se lean las "Release Notes" (yo, desde luego, las leo sólo cuando todo falla).

Está claro que la prioridad de los programadores de Intel es sabotear tarjetas antiguas.