Así pues, para retomar el control absoluto del sonido en tu sistema:

  $ sudo apt-get remove pulseaudio
  

Alguien dirá que el problema ahora es que distintas aplicaciones no pueden reproducir audio simultáneamente. Respondo que, por una parte, no todas las aplicaciones reconocen Pulse Audio por lo que probablemente antes tampoco era posible. Y, por otra parte, que ALSA sí lo permite. Sólo es necesario activar la mezcla por software dmix sobre la salida de audio. Simplemente lléva este código a tu .asoundrc.

# .asoundrc - Personal configuration file for ALSA

# Copyright (C) 2009 Ismael Valladolid Torres <ivalladt@gmail.com>

# 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 2
# of the License, or (at your option) any later version.

# 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, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA.

# See the file COPYING for details.

pcm.ossmix {
    type dmix
    ipc_key 1021                # must be unique!
    ipc_perm 0660               # sound for everybody (at least in your group)
    #ipc_key_add_uid false      # let multiple users share
    slave {
        pcm "hw:0,0"
        period_time 0
        period_size 1024        # must be power of 2
        buffer_size 8192        # dito
        #format "S32_LE"
        #periods 128            # dito
        #rate 8000              # with rate 8000 you *will* hear
    }                           # if ossmix is used 

    # bindings are cool. This says, that only the first
    # two channels are to be used by dmix, which is enough for
    # (most) oss apps and also lets multichannel chios work
    # much faster:
    bindings {
        0 0   # from 0 => to 0
        1 1   # from 1 => to 1
    }
}

# Redirect to ossmix
pcm.!default {
    type plug
    slave.pcm "ossmix"     # use our new PCM here
}

# Redirect to ossmix
pcm.dsp {
    type plug
    slave.pcm "ossmix"     # use our new PCM here
}

# mixer like above
ctl.mixer {
    type hw
    card 0
}

# Local Variables:
# mode: conf
# End:

Ahora la salida llamada default, la que por omisión utilizan todas las aplicaciones compatibles con ALSA para reproducir audio, implemente mezcla por software desde todas las aplicaciones que la están utilizando. En mi máquina, así, es posible reproducir simultáneamente audio desde clips en YouTube vía Flash en Firefox, Spotify, mplayer, Audacious, Skype y cualquier otra.

Sólo dos avisos. Si alguna aplicación utiliza explícitamente la salida hw:0,0 todo deja de funcionar. La mezcla por software queda configurada para la salida llamada default y no para ninguna otra. Por otra parte, de nuevo, si cualquier aplicación consigue reproducir con éxito audio utilizando la emulación OSS, la cosa de nuevo deja de funcionar.

Un documento fascinante. Se trata de un gráfico a modo de árbol genealógico de las distribuciones Linux en la actualidad, todas procedentes de las tres grandes semillas de nuestro jardín informático; Debian, Slackware y Red Hat.

Visto en Userlinux.net.

Puredyne es una distribución orientada al trabajo creativo para aquellos que buscan herramientas apartedas del estandar. Facilita las mejores aplicaciones creativas en estado experimental además de un sólido conjunto de herramientas para el trabajo con imagen, audio y vídeo en un paquete minimalista muy rápido.

Puredyne está optimizada para el procesado de audio y vídeo en tiempo real. Se distingue por facilitar un kernel de muy baja latencia, para la responsividad que necesitan los artistas que trabajan en este campo.

Está basada en Ubuntu y Debian Live, y todos los paquetes facilitados por Puredyne pueden ser fácilmente utilizados en cualquiera de los sabores de Linux. Descarga Puredyne, utilízala, compártela, modifícala, únete al equipo de desarrollo o haz lo que quieras con ella.

La conversación transcurre sobre un «ciclo meta release» que vería cómo las próximas revisiones de Ubuntu y Debian congelan sus fechas de congelación. Parte del retraso se debería a la incorporación de GNOME 3.0, esperada para primavera de 2010, sobre la misma fecha inicialmente esperada para Ubuntu 10.04. Los desarrolladores de Ubuntu liberan versiones de forma regular cada seis meses, soportadas con actualizaciones hasta dieciocho meses, pero hay versiones LTS como la Ubuntu 8.04 LTS que son actualizadas durante tres años para la versión de escritorio y cinco años para la versión de servidor.

Visto en The H Open Source. Foto de Bartosz Senderek.

El editor de Linux AV se enorgullece en presentarse como «experto en la categoría Linux» para Wikio. Como tal, irá siendo presentada aquí la lista de blogs dedicados a Linux más populares en Wikio de forma mensual. Ésta es la primera lista.

¿Estás en la lista? ¡Enhorabuena! Otra de las cosas que me pide Wikio es crear una red entre los sitios más populares dedicados a Linux a partir de nuestros respectivos blogroll. Así que me permito pedirte, estés o no en la lista, que añadas Linux AV a tu blogroll y me dejes un mensaje de correo electrónico o un comentario a este artículo indicándome la dirección de tu blog para que yo haga lo propio.

<a href="http://www.linuxav.net/">Linux AV</a>

¡Gracias! ¡Y que los Reyes Magos te traigan mucho software libre!

Es el nombre que le han dado los de PING Labs a un ataque que afecta, demostrado, a Ubuntu y a Debian, pero seguramente también a cualquier otra distribución. El ataque permite acceder sin restricciones a una sesión bloqueada por un salvapantallas.

El nombre hace referencia a la facilidad con la que es posible ejecutarlo. Aunque la probabilidad de éxito es mínima, basta con pasar por delante del ordenador bloqueado y pulsar «Alt+PetSis+F». Resulta que el kernel Linux captura ciertas combinaciones de teclas, todas activadas por la combinación «Alt+PetSis», para realizar funciones de emergencia. En particular la citada combinación activa el OOM Killer. Éste libera memoria de forma automática. Si la CPU está demasiado ocupada, el el OOM Killer elimina algún proceso para poder retomar el control del sistema. Existe una mínima posibilidad de que dicho proceso sea el salvapantallas. Éste entonces se cierra y la señora de la limpieza, o cualquiera que pase por allí, puede entonces acceder al escritorio.

En Xombra tienes toda la información. Foto de Szater.

La forma normal de utilizarlo es la siguiente:

  $ autoretweet -u usuario -p lksnfd -k linux
  

Se trata de los tres parámetros obligatorios. El nombre de usuario en el servicio Twitter, la contraseña, y la palabra clave que disparará el bot una vez aparezca en las búsquedas. Utilizado así, el bot simplemente hace un retweet al usuario que ha publicado un mensaje conteniendo la palabra clave. El usuario podría así identificarte como interesado en el tema para el cual dicha palabra clave es representativa y devolverte su seguimiento.

Hay no obstante formas más sofisticadas de utilizarlo, mediante los siguientes parámetros opcionales.

-s status

Utiliza una cadena de texto determinada en lugar del retweet. Dicha cadena podría contener un enlace, y utilizar así el bot para la promoción de un sitio y no para conseguir seguimientos. Utilizar con precaución dado que el uso de una cadena repetida acaba redundando en que la cuenta que lo hace es marcada como sospechosa y desactivada.

-f url

Averigua el feed XML para el sitio cuya URL se proporciona. De dicho feed toma las entradas que contienen la palabra clave indicada y presenta en cada nuevo estado el enlace y el título de dicha entrada. Eventualmente útil para promocionar un sitio. De nuevo, utilizar con precaución.

-n num_results

El número de resultados a ser devuelto en cada búsqueda.

-p poll_frequency

El tiempo entre dos búsquedas consecutivas.

-d delay_updates

El tiempo entre dos envíos al sistema Twitter. Si va a utilizarse un mensaje repetido, configurar un valor lo suficientemente alto para evitar que la cuenta sea marcada como sospechosa.

-r random

Genera para cada envío un hashtag aleatorio de la longitud indicada. Permite que la cadena de texto sea distinta en cada envío y eventualmente que la cuenta no sea marcada así como sospechosa.

-v

Salida prólija, presentando un informe completo de todas las acciones realizadas por el script.

Ante la posibilidad de que Twitter considere maliciosa la actividad del bot y marque la cuenta como sospechosa, no dudo en recomendar no utilizarlo con tu propia cuenta personal. Copia el código en un fichero llamado autoretweet. Activa el permiso de ejecución y guárdalo en un directorio en tu path actual. Crea ahora una cuenta troll. Sigue la convención de utilizar para el avatar de dicha cuenta una nariz roja. Utiliza ahora esa cuenta para probar el bot. Disfrútalo.

#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper;
use Getopt::Std;
use HTML::TokeParser;
use LWP::Simple;
use Net::Twitter;
use XML::Feed;

local $| = 1; # auto flush stdout
binmode STDOUT, ':utf8';

my $username;
my $password;
my $keyword;
my $status;

my $num_results = 5;
my $poll_frequency = 100;
my $delay_updates = 60;

my $random = 0;
my $verbose = 0;

my @feeds;
my @goods = ();

# Get command line options
my %opts=();
getopts("u:p:k:f:s:n:q:d:r:v",\%opts);

# Parse command line options, die if any not defined
if (defined $opts{u}) {
    $username = $opts{u};
}
else {
    die "username not defined!";
}

if (defined $opts{p}) {
    $password = $opts{p};
}
else {
    die "password not defined!";
}

if (defined $opts{k}) {
    $keyword = $opts{k};
}
else {
    die "keyword not defined!";
}

if (defined $opts{f}) {
    my $url = $opts{f};
    @feeds = XML::Feed->find_feeds($url);

    if ($feeds[0]) {
        my $feed = XML::Feed->parse(URI->new($feeds[0]));
        my @entries = $feed->entries();

        foreach my $entry (@entries) {
            if ($entry->link() =~ m/$keyword/) {
                push (@goods, $entry->link());
            }
        }
    }
}

if (defined $opts{s}) {
    $status = $opts{s};
    if (length($status) > 140) {
        die "status too long!";
    }
}

if (defined $opts{n}) {
    $num_results = $opts{n};
}

if (defined $opts{q}) {
    $poll_frequency = $opts{q};
}

if (defined $opts{d}) {
    $delay_updates = $opts{d};
}

if (defined $opts{r}) {
    $random = $opts{r};
}

if (defined $opts{v}) {
    $verbose = 1;
}

printf "get %d search results on keyword \"%s\" each %d seconds\n",
    $num_results, $keyword, $poll_frequency;
printf "retweet from user %s password %s each %d seconds\n",
    $username, $password, $delay_updates;
if (scalar (@goods)) {
    printf "use random status relevant for keyword \"%s\"\nfrom feed %s\n",
    $keyword, $feeds[0];
}
elsif ($status) {
    printf "use status \"%s\"\n", $status;
}
if ($verbose) {
    print "be verbose\n";
}

# Create a Net:Twitter object
my $nt = Net::Twitter->new({
    username => $username,
    password => $password,
    traits => [qw/API::REST/, qw/API::Search/]
});

# So only new search results are retweeted
my $since_id = 0;
my $max_id = 0;

while (1) {

    # Get search results on keyword
    printf "searching ";
    my $tweets = $nt->search({
        q => $keyword,
        rpp => $num_results,
        lang => 'es',
        $since_id ? (since_id => $since_id) : ()
    });

    if (defined $tweets) {
        print "ok\n";
    }
    else {
        print "failed!\n";
    }   

    # For each search result...
    for my $t (@{$tweets->{results}}) {
        next unless $t->{id} > $since_id;
        if ($t->{id} > $max_id) {
            $max_id = $t->{id};
        }
        # Don't retweet if an own tweet or from user is the keyword
        # also if already a retweet when no status is given
        if (
            ($t->{from_user} ne $username) &&
            ($t->{from_user} ne $keyword) &&
            (($status) || ($t->{text} !~ m/^RT/))
            ) {
            # Build retweet string
            my $s;
            # Prepend a random hashtag
            if ($random > 0) {
                $s .= "#";
                my @chars=('a'..'z','0'..'9');
                foreach (1..$random)
                {
                    $s .= $chars[rand @chars];
                }
                $s .= " ";
            }
            # Use feed entry with given keyword if any
            if (scalar(@goods) > 0) {
                $s .= "@" . $t->{from_user} . " ";

                my $uri = $goods [rand @goods];
                my $content = get($uri);
                utf8::decode($content);

                my $p = HTML::TokeParser->new(\$content);
                if ($p->get_tag('title')) {
                    my $title = $p->get_trimmed_text();
                    $title =~ s/&/&/g;
                    $s .= $title . ". ";
                }
                $s .= $uri;
            }
            # Use specified status if any
            elsif ($status) {
                $s .= "@" . $t->{from_user} . " " . $status;
            }
            # Use a simple retweet
            else {
                $s .= "RT @" . $t->{from_user} . ": " . $t->{text};
            }

            if ($verbose) {
                printf "%s\n", $s;
            }
            printf "%s retweet", $t->{from_user};

            # Send update
            if ($nt->update($s)) {
                print "ed ok\n";
            }
            else {
                print " failed!\n";
            }
            sleep $delay_updates;
        }
    }

    # Set last received search result and sleep for a while
    $since_id = $max_id;
    sleep $poll_frequency;
}

El usuario de Debian y Ubuntu sólo tiene que instalar el paquete libnet-twitter-perl. El bot sin embargo debería ser utilizable en otros sistemas como Windows. Instálese en ese caso ActivePerl o, mejor aún, el entorno Cygwin y obténgase la librería necesaria utilizando CPAN.

Un primer consejo es, desde luego, desactivar las extensiones mientras no las estás necesitando. Firebug, por ejemplo, es, desde luego, una aplicación killer para desarrolladores web que hace imprescindible a Firefox. Pero ralentiza el uso del navegador, y es raro que la necesites más que un par de ocasiones al mes —a no ser, por supuesto, que seas un profesional en el tema—. Lo dicho para Firebug vale para muchas otras extensiones complejas. Yo, por ejemplo, hoy por hoy sólo necesito Google Gears para subir clips a YouTube. El resto del tiempo está desactivada.

Por lo demás hay una serie de parámetros que es posible optimizar, y se listan debajo. Puedes, por supuesto, visitar about:config y configurarlas una por una. O puedes llevar ese código a prefs.js. La sugerencia es, desde luego, llevar esas opciones a un fichero user.js en el directorio de configuración de Firefox, junto al citado prefs.js. El fichero user.js es así portable de máquina en máquina. En mi caso, estas opciones están en todas las máquinas donde uso Firefox.

user_pref("network.http.pipelining", true);
user_pref("network.http.proxy.pipelining", true);
user_pref("network.http.pipelining.maxrequests", 30);
user_pref("nglayout.initialpaint.delay", 0);
user_pref("config.trim_on_minimize", true);
user_pref("browser.cache.memory.capacity", 27648);
user_pref("browser.cache.memory.enable", true);
user_pref("network.prefetch-next", false);
user_pref("network.http.max-connections", 60);
user_pref("network.http.max-connections-per-server", 32);
user_pref("network.http.max-persistent-connections-per-proxy", 16);
user_pref("network.http.max-persistent-connections-per-server", 16);
user_pref("network.dns.disableIPv6", true);
user_pref("content.notify.backoffcount", 5);
user_pref("ui.submenuDelay", 0);
user_pref("plugin.expose_full_path", true);
user_pref("browser.sessionhistory.max_total_viewers", 2);
user_pref("browser.sessionhistory.max_entries", 10);

• El pipelining en las conexiones HTTP 1.1 reduce la carga de red y el tiempo de carga de las páginas sobre conexiones cuando la latencia es demasiado elevada. Teóricamente no todos los servidores lo soportan y podrían comportarse incorrectamente si reciben peticiones de este tipo, de ahí que muchos aconsejen no activarlo. Yo no he encontrado problemas y sí una mejora clara en el rendimiento. 30 es una buena cifra para el máximo número de este tipo de peticiones concurrentes.
• Tiene sentido visualizar la página ya según empieza a ser cargada, de ahí que se elimine cualquier intervalo antes de empezar a hacerlo.
• Mejora también el rendimiento permitir que la aplicación haga swap una vez minimizada. De esta forma se libera memoria que hace más agil el uso de tu sistema operativo.
• Almacenar en una cache imágenes, elementos de interfaz de usuario o páginas seguras acelera el rendimiento. ¡Piensa en la diferencia que supondría tener que decodificar estas últimas cada vez que son cargadas!
• Una opción polémica es la de permitir la precarga de las páginas tras los enlaces que componen una página. Yo voto por liberar a la CPU de la tarea de precargar enlaces que probablemente no van a ser seguidos.
• El ADSL y en general toda banda ancha permite un número mayor de conexiones HTTP concurrentes que las que permitían las conexiones por módem. Aumentar ese valor hoy por hoy mejora el rendimiento en todos los casos.
• Mientras IPv6 no exista, desactivarlo también mejora el rendimiento.
• Posiblemente sea sólo psicológico, pero eliminar el retardo con el que se abren las opciones del menú de la aplicación repercute en la sensación de un mejor rendimiento.
• Por último, es improbable que te interesen páginas más allá de las diez últimas visitadas. Se libera así memoria y mejora el rendimiento de la aplicación y del sistema operativo.

Haz la prueba y deja un comentario. ¿Notas la mejora en el rendimiento? Yo desde luego que sí. ¿Algún truco más?

Ah, el usuario de Ubuntu dispone por supuesto de Firefox tal cual. El usuario de Debian puede aplicar exactamente las mismas opciones en Iceweasel.

Captura de Pentadact.

En particular, en el trabajo con audio, permitir un funcionamiento en tiempo real o apropiativo del servidor JACK facilita las latencias más bajas y la ausencia total de artificios en el audio. En el momento en el que JACK necesite la CPU, ninguna otra tarea en el sistema va a competir por ella. Cuando tú tienes el paquete de Donuts en la mano, tus amigos sólo comen los que quieres que coman.

Existe la posibilidad de acceder a un kernel realtime empaquetado en la mayor parte de las distribuciones más populares. Esta explicación te permite disponer de la ultimísima versión del mismo en tu Debian o Ubuntu, sin que necesites esperar a que alguien lo compile y lo empaquete por ti.

Requisitos previos

Asegúrate de que tu usuario es miembro del grupo src ejecutando el comando groups. Si src no aparece entre los grupos listados ejecuta como root:

  # adduser ismael src
  

Sustituye por supuesto ismael por tu nombre de usuario en tu sistema. Ahora reinicia la sesión y vuelve a ejecutar groups para comprobarlo. Esto es necesario para poder trabajar bajo el directorio /usr/src.

  $ groups ismael
  ismael : ismael dialout cdrom floppy audio src video plugdev netdev
  

Si quieres estar pendiente de las novedades en el soporte realtime al kernel Linux, deberías estar suscrito a la lista de correo linux-rt-users en vger.kernel.org. Simplemente envía un mensaje de correo sin asunto a majordomo@vger.kernel.org con el siguiente texto en el cuerpo:

  subscribe linux-rt-users
  

Recibirás mensajes de progreso y confirmación, simplemente sigue el proceso sugerido.

Una vez suscrito, las novedades en la serie preempt-rt del kernel son anunciadas en mensajes de correo recibidos de Thomas Gleixner con un asunto como éste.

  [Announce] 2.6.29.4-rt16
  

Te resultará sencillo filtrar estos mensajes, por ejemplo moviéndolos a una mbox separada o marcándolos con una estrella en Gmail. Explicar la forma de hacer esto queda fuera del alcance de este artículo.

El cuerpo del mensaje contendrá información como ésta.

  We are pleased to announce the next update to our new preempt-rt
  series.

  - rebase to 2.6.29.4 (no conflicts)
  - futex updates (tglx, dvhart)

  Download locations:

  http://rt.et.redhat.com/download/
  http://www.kernel.org/pub/linux/kernel/projects/rt/

  Information on the RT patch can be found at:

  http://rt.wiki.kernel.org/index.php/Main_Page

  to build the 2.6.29.4-rt16 tree, the following patches should be
  applied:

  http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.29.4.tar.bz2
  http://www.kernel.org/pub/linux/kernel/projects/rt/patch-2.6.29.4-rt16.bz2

  The broken out patches are also available at the same download
  locations.

  Enjoy !

  tglx

  --
  To unsubscribe from this list: send the line "unsubscribe linux-rt-users" in
  the body of a message to majordomo@vger.kernel.org
  More majordomo info at  http://vger.kernel.org/majordomo-info.html
  

Descarga y parchea el kernel

Primero descarga el kernel sobre el que hay que aplicar los parches, en nuestro caso el 2.6.29.4.

  $ cd /usr/src
  $ wget http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.29.4.tar.bz2
  

Y ahora el parche realtime que se está anunciando con el mensaje de correo.

  $ wget http://www.kernel.org/pub/linux/kernel/projects/rt/patch-2.6.29.4-rt16.bz2
  

O bien visita esa URL y mira qué hay de nuevo. Para cuando vayas a compilar, una versión más reciente del parche podría estar disponible.

Descomprime ahora las fuentes del kernel.

  $ tar xvfj linux-2.6.29.4.tar.bz2
  

Y aplica el parche realtime.

  $ cd linux-2.6.29.4
  $ bzcat ../patch-2.6.29.4-rt16.bz2 | patch -p1
  

Configura y compila el kernel

Procede ahora a configurar el kernel.

  $ make clean && make mrproper
  $ cp /boot/config-`uname -r` .config
  $ make menuconfig
  

Visita ahora la opción de menú Processor type and features:

Asegúrate de que High Resolution Timer Support y Symmetric multi-processing support están activados.

En Processor family, elige la CPU de tu sistema.

En Preemption Mode, elige Complete Preemption (Real-Time).

En Timer frequency, selecciona 1000 HZ.

Selecciona Exit y contesta Yes a la pregunta sobre si salvar la configuración del kernel.

Es momento de iniciar la compilación. A la versión del kernel ya le habrá sido añadida la del parche realtime, y como revisión utilizamos el nombre de nuestra máquina —recuerda que hemos elegido nuestra CPU y el kernel podría no ser utilizable en otros ordenadores— y una marca temporal. Construirás la imagen del kernel y el correspondiente paquete con los ficheros de cabecera, necesarios más tarde para compilar tus módulos. Ejecuta make-kpkg, hazte un café, o dos, y vuelve cuando haya terminado.

  $ make-kpkg clean
  $ make-kpkg --rootcmd fakeroot --initrd --revision `hostname -s`~`date +%Y%m%d` kernel_image kernel_headers
  

Estás ahora haciendo surf sobre la cresta de peligrosas olas. No hay ninguna garantía de que todo va a funcionar bien. De hecho, lo que se espera de ti ahora es que reportes cualquier inconveniente a la lista de correo. El placer de estar siendo el primero en correr algo que a los usuarios de Ubuntu Studio les quedan meses para disfrutar, por supuesto no te lo quita nadie.

Utiliza Cyclictest para medir la respuesta de tu sistema con temporizadores de alta resolución y baja latencia. Deja tus resultados junto con la configuración de tu máquina y la versión del kernel que estás usando en los comentarios.

Sólo para gurús

Si eres usuario de Debian inestable, podrías haber notado que compilar un kernel utilizable se ha complicado en los últimos tiempos, después de las últimas modificaciones de Manoj Srivastava al paquete kernel-package. Resumiendo, Manoj asume ahora que cada empaquetador podría desear elegir su propia forma de crear la imagen initrd con los módulos necesarios para el arranque de la máquina. No se presume si por defecto se va a utilizar initramfs o yaird, o cualquier otra aplicación. De ahí que aunque especifiques –initrd como argumento a make-kpkg, aquella imagen no va a ser creada y te expones a un kernel panic durante el arranque con el nuevo núcleo.

La solución es copiar uno de los scripts de ejemplo proporcionados con el paquete kernel-package al directorio que aloja aquellos a ser ejecutados durante la post instalación del kernel. Por si el update-grub final no se ejecutase en el momento adecuado, es decir, después de que la imagen initrd haya sido creada, copiaremos allí también el ejecutable, modificando los nombres de fichero para elegir su orden de ejecución.

  # cp /usr/share/kernel-package/examples/etc/kernel/postinst.d/initramfs /etc/kernel/postinst.d/40initramfs
  # cp /usr/sbin/update-grub /etc/kernel/postinst.d/99update-grub
  

Ah, si la compilación falla por la ausencia del fichero zlib.h, simplemente instala el paquete zlib1g-dev y prueba de nuevo.

Buenas noches y buena suerte.

Antes de lanzarme al informe, debo añadir unas palabras sobre LilyPond y su especial relación con los programas revisados aquí.

Ya he escrito sobre el asombroso LilyPond en artículos anteriores, y me hace feliz informar de que el proyecto sigue vivo y floreciente, en la versión 2.12 de su rama estable. Las funciones de desarrollo y mantenimiento las lleva a cabo una numerosa comunidad de usuarios y programadores, y se trata de un proyecto maduro. Muchos usuarios se han pasado a LilyPond desde otros populares programas de notación, a pesar de la interfaz basada en texto y la operativa desde línea de comandos. La calidad de la salida de LilyPond es así de atractiva.

Dado que la interfaz está basada en texto ASCII, muchos usuarios buscan una interfaz gráfica alternativa para LilyPond. La mayor parte de los programas presentados en este artículo pueden ser considerados front ends a LilyPond, pero varían en la clase y nivel de soporte a LilyPond. Los hay entornos de edición de texto especializados en notación y secuenciación. En todos los casos LilyPond es el motor que proporciona la capacidad de notación. En algunos casos se requiere cierto conocimiento de LilyPond, mientras que en otros la presencia de LilyPond está oculta por completo al usuario.

Comentarios generales

Programar una aplicación de notación pone en problemas a los desarrolladores. Un programa de notación completo implica un motor gráfico complejo, entrada y salida de audio y MIDI y soporte para importar y exportar una gran variedad de formatos de ficheros. Mas aún, el desarrollador debe decidir si su programa va a servir como ayuda al compositor o simplemente como máquina de escribir del músico. Esta distinción impone importantes aspectos del diseño básico de la aplicación, especialmente a nivel de interfaz de usuario.

Hay paquetes que combinan los dos factores de diseño con éxito, pero la necesidad de esa máquina de escribir de calidad profesional siempre demanda una aplicación dedicada. La música imprimida desde un secuenciador de uso general es útil, pero raramente es favorable la comparación con la salida de una aplicación dedicada como es LilyPond.

Los requisitos esenciales para las aplicaciones de notación incluyen funciones de trazado de partitura, métodos de entrada de datos, paletas de símbolos musicales, soporte para salida de audio y opciones para impresión de la partitura finalizada. Los programas básicos pueden incluir sólo un subconjunto de las características posibles, mientras que aplicaciones más profesionales facilitan un mayor control sobre los detalles del trabajo. Por supuesto que mayor control implica mayor complejidad. Los diseñadores de aplicaciones de notación trabajan duro para compensar la facilidad de uso con una plétora de características.

Considérense las necesidades de distintos tipos de usuario; los compositores de escritorio pueden requerir sólo una paleta de notación simple, pero podrían necesitar soporte para entrada MIDI, desde fichero o desde un teclado, y una representación precisa de ess datos. Compositores avanzados podrían no necesitar MIDI pero características como una amplia paleta de símbolos, extracción de partes, o incluso soporte para la manipulación de partituras desde rutinas programadas en Python u otros lenguajes de propósito general. El mundo comercial del software musical ofrece programas que cubren estas necesidades. Finale y Sibelius son dos de las aplicaciones de notación completas más conocidas en el mundo Windows y Mac, y otras aplicaciones más económicas y con menos características están también disponibles.

En los secuenciadores de audio y MIDI modernos se dispone de notación musical, pero la implementación es necesariamente limitada. Un programa de notación completo tiene que ser una aplicación independiente, aunque debe admitirse que las herramientas de notación en aplicaciones como Cubase o Rosegarden son adecuadas para tareas como las hojas principales, las guías de acordes y para piezas relativamente cortas. Un trabajo más ambicioso puede llevarse a cabo con estos programas, pero sus características de notación son sólo un componente de un diseño multipropósito. Debo señalar que los desarrolladores de Rosegarden han prestado gran atención a sus características de notación, y merece la pena recordar que Rosegarden dispone de exportación al formato LilyPond.

El equipo de pruebas

He elegido un sistema sencillo Ubuntu 8.10 con el kernel 2.6.27-9 como plataforma de pruebas. Mi decisión ha estado influida en parte por la disponibilidad de los paquetes en sus repositorios, donde dispongo además de cualquier utilidad de desarrollo para satisfacer dependencias avanzadas. El soporte realtime en este caso no es obligatorio, aunque en ese caso mejoraría la calidad de la salida de audio.

Denemo

Denemo es a la vez un editor con interfaz de usuario para compositores con editor de partituras LilyPond y un entorno basado en notación para la composición con MIDI. El trabajo reciente en Denemo ha mejorado la interfaz de usuario y la estabilidad general de la aplicación, y en la versión pública 0.8.0 se han añadido muchas nuevas características. El trabajo de desarrollo es intenso y el equipo está siempre abierto a sugerencias para nuevas e incluso inhabituales funciones.

La intefaz de Denemo opta por un sistema de menús en lugar de por paletas gráficas que presenten la colección de símbolos de notación. A primera vista puede pensarse que este diseño impide un trabajo rápido, pero el punto clave para la productividad en Denemo es su uso extensivo de atajos de teclado. Casi cualquier función del programa está disponible desde el teclado del ordenador, y una vez que el usuario se acostumbra a la asignación de atajos, el trabajo es muy rápido.

Es posible la entrada de datos utilizando MIDI, en tiempo real o desde fichero, ya sea un fichero existente de Denemo, una partitura de LilyPond, o incluso audio en tiempo real (!). Además, Denemo puede extenderse mediante el lenguaje de programación Scheme. El usuario puede definir y visualizar nuevas opciones de menú para el programa, dándole así a Denemo una posición única entre los programas de ayuda para LilyPond que se presentan en este artículo. Scheme no es un lenguaje difícil de aprender —es una variedad de Lisp— y aprender al menos un poco facilita un gran poder al usuario de Denemo.

Denemo está repleto de herramientas molonas para compositores. Puedes cambiar entre edición gráfica o basada en texto, se soportan símbolos de acordes para bajo y guitarra, y el soporte a Scheme permitiría incluso la composición algorítmica —para los desarrolladores de Denemo; ¡esto molaría un montón!—. Puedes definir qué aplicaciones externas usarás para reproducir audio y MIDI, incluyendo la remarcable posibilidad de utilizar Csound como motor de audio. Los compositores pueden así acceder a las increibles características de Csound desde una aplicación de notación estándar. El secuenciador Rosegarden puede ser usado también como aplicación de notación para Csound, pero no facilita una conexión con Csouns tan integrada. Denemo es la única aplicación que facilita este tipo de conexión para la salida de audio.

Los ficheros pueden ser cargados y salvados en el formato XML propio de Denemo o en el formato nativo de LilyPond. Es posible también exportar a PDF. En el momento de escribir esto, no se soporta MusicXML para importar o exportar, pero la aplicación musicxml2ly de LilyPond permite la traducción de ficheros entre MusicXML y LilyPond.

Versiones anteriores de Denemo sufrían de problemas de estabilidad, y de una imponente curva de aprendizaje. Me alegra informar de que la estabilidad ya no es unproblema, y de que existe mucho material de referencia actualizado, ficheros de ejemplo y documentación para el usuario.

Frescobaldi

Frescobaldi es una obra de los desarrolladores de la fantástica aplicación lilypond-kde4. Frescobaldi no es en sí mismo un editor de notación. Más bien facilita un entorno especializado para editar partituras en el formato nativo basado en texto de LilyPond. Facilita amenidades como resaltado de sintaxis, ayuda inmediata —tanto para LilyPond como para el propio Frescobaldi— y previsualización de la partitura. La interfaz de usuario está refinada, es atractiva, y el programa se domina sin dificultad.

El último Frescobaldi requiere de KDE4 actualizado, y no es probable que esté disponible desde repositorios para sistemas Linux algo antiguos —como 64 Studio 2.1 ó JAD 1.0—. Está incluso ausente de mis repositorios para Ubuntu 8.10 pero, como mencioné antes, el sistema está lo suficientemente actualizado como para facilitar su compilación. Las dependencias perdidas las resuelve Synaptic fácilmente, y no he tenido problemas para compilar e instalar versiones recientes de la aplicación.

Aún así tengo sugerencias para los desarrolladores. En la actualidad el flujo de trabajo te requiere salvar las ediciones antes de previsualizarlas. Me gustaría un modo de edición con previsualización tras un clic, que no requiera de un salvado explícito, si esto es posible. Tengo otro inconveniente con la función de impresión de Frescobaldi. Según escribo esto, Frescobaldi sólo imprime a PDF o PostScript. Me gustaría poder utilizar la impresora de mi sistema desde el propio programa. Por último, dado que LilyPond es capaz de generar un fichero MIDI desde su formato nativo, ¿por qué no facilitar una función de reproducción MIDI?

Aparte de mis deseos, me gusta Frescobaldi y voy a seguir su desarrollo de cerca. Si buscabas un editor LilyPond dedicado —y no te atreves a aprender Emacs— deberías probar Frescobaldi.

Canorus

Canorus comenzó como fork del proyecto NoteEdit que describiré en la segunda parte de este artículo. En un momento dado pareció que el programador de NoteEdit iba a abandonar el proyecto, así que Reinhard Katzmann formó un nuevo grupo de desarrolladores para el mismo. Canorus es el resultado de su esfuerzo para proporcionar «un editor de partituras libre y extensible que soporte escritura de notas, importación y exportación de distintos formatos de fichero, entrada y salida MIDI, scripting y más». La última beta de Canorus 0.7 es su última parada antes de la meta.

El sitio de la aplicación reconoce que el software es calidad beta. Aunque cada nuevo lanzamiento incluye características no disponibles en versiones anteriores, podría no ser tan fantásticamente estable como la versión pública 0.5. Resumiendo, las versiones beta no deberían considerarse para un trabajo serio en este punto. Eres bienvenido a probarlas, los desarrolladores quieren informes de sus usuarios, pero si te subes a la ola, ten cuidado.

Se facilitan versiones estables y en desarrollo desde los enlaces en el sitio de la aplicación. Están disponibles paquetes instalables para Debian y Windows, así como paquetes con fuentes independientes de la plataforma en formatos zip y tarball.

Construir la aplicación completa requiere de ciertas dependencias, incluyendo Qt4 reciente y la utilidad cmake. Son necesarios LaTeX y el visualizador LyX para construir la documentación, pero las versiones que he encontrado en Ubuntu 8.10 son inutilizables con Canorus, así que me quedé sin dicha documentación. Por suerte se trata de un paso opcional, así que si el compilado parece fallar con la documentación, simplemente sigue con el resto de pasos. No dispondrás de la ayuda para el usuario en el menú Help, pero esta carencia se ve mitigada por los avisos de la interfaz de usuario, y por la relativa sencillez de uso de la aplicación.

Me doy cuenta de que estoy probando una versión beta y de que la documentación estará disponible en la versión pública final, pero creo que sería sabio por parte de los desarrolladores facilitar la documentación ya compilada en este tipo de versiones previas. Me sorprende que un sistema tan reciente como Ubuntu 8.10 no facilite una cadena de herramientas de compilado que funcione para construir la documentación de Canorus, y me gustaría poder descargar esa documentación del sitio de Canorus. Sea lo que sea que se incluya en el paquete final, una versión HTML simple en el sitio web sería un feliz aporte al material disponible.

El instalador no añadió un icono a mi menú de aplicaciones, así que inicié el programa escribiendo canorus en mi ventana de terminal. No hay ayuda a la línea de comandos utilizando -h ó –help. Cuando se inicia Canorus, verás una pantalla splash durante unos segundos, y después un lienzo con una marca de inicio sencilla.

Canorus adopta y extiende las características que ya se encontraban en NoteEdit. Como características resaltables se incluyen un excelente método de entrada para notación polifónica, conectividad MIDI con el secuenciador ALSA —esto es, entrada y salida MIDI multiplexada—, scripting con Python o Ruby, una rica selección de símbolos estándar y soporte para eventos definidos por el usuario.

Canorus funciona en los modos de selección o edición. En el último, los símbolos musicales se incluyan y se borran de forma definible por el usuario tanto con el ratón como con atajos de teclado típicos de Emacs —Del para borrar el símbolo seleccionado, Ctrl-Z para undo, Ctrl-A para seleccionar todo, etc.—. Puedes dividir un proyecto en distintas hojas. Cada una incluye controles para canales MIDI y asignaciones típicas de instrumentos General MIDI. Se prescinde de menús de contexto a favor de menús desplegables, lo que puede frustrar a algunos usuarios. En mi opinión en cambio ese diseño deja la pantalla libre de saturaciones molestas.

Sobre el soporte a ficheros; pueden importarse ficheros MIDI o en el formato MusicXML. Puedes salvar tu trabajo en el formato de projecto canorus .can o en el formato basado en XML, o exportarlo para LilyPond o como MusicXML. Puedes también exportar tu trabajo como fichero MIDI o como fichero gráfico en formato PDF o SVG. Canorus imprime tu notación filtrándola a través de LilyPond. Designas el binario LilyPond en el menú Tools/Settings, donde también seleccionas tu visualizador PDF favorito —el formato de salida por defecto en LilyPond—.

Canorus se parece a su excelente predecesor en su clara presentación y en su sencillez de uso. Como he mencionado, las versiones beta requieren probadores, así que si te apetece algo de riesgo, puedes ayudar con el desarrollo de este fantástico programa.

Visto en Linux Journal.