Key-value pair files to xml

This sed script will read in a key-value pairs file, you know, like this:

NAME=Joe & Freds
CLASS=Cafe

into xsl attribute lists, like this:

name="Joe & Freds" class="Cafe"

ready to be stuck in the middle of a tag.

sed -e '
/=/{ # make sure it has an = sign in
h # save current line
s/=.*/=/
y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/
x # get back original line
s/^[^=]*=// # loose attribute name
/./{ # anything left?
 s/&/&/
 s/"/"/
 s/</&lt;/
 s/>/&gt;/
 s/^/"/;
 s/$/"/;
 H #append to stored line
 x # get it all back
 s/\n//
 p
}
d
}
d
'

ALSA stuttering sound

Trouble with applications playing audio stuttering badly, particularly mplayer with:

alsa-space: xrun of at least 0.068 msecs. resetting stream0.4% 10 0
alsa-space: xrun of at least 0.069 msecs. resetting stream0.4% 10 0
alsa-space: xrun of at least 0.065 msecs. resetting stream0.4% 10 0

Wonder no more, read on at the ALSA Wiki, particularly the comment by Daniel further down on why 48000 is sub-optimal in most cases.

Closed Source Kernel Drivers with B#

I commented in recently on use of B# for Linux kernel modules, a B# VM can be done in 8K or less, has a small instruction set and can implement interrupt handlers.

On reflection this is more likely to be popular under the BSD’s who don’t have so much GPL philosophy to contend with.

Hardware manufacturers could provide one set of cross-platform B# binary drivers to run under MAC-OS X and *BSD - any architecture.

Hardware drivers need to make use of a very limited part of the kernel API, the main purpose of a hardware driver is to manage resources for the hardware and implement a standard API for that piece of hardware.

The B# glue layer - somewhat like ndis-wrappers - will be the layer that copes with evolving kernel API’s. And possibly also get ported to the linux kernel - and I really don’t know if this a good thing.  Although Linus has commented against static kernel APIs to support binary modules, he has also refrained from heartily condemning suppliers of binary only kernel modules - often providing their on source-based API glue to the binary module.

While I’m a GPL fan and paying member of the FSF (not card carrying:- my bootable FSF membership card had developed some nasty blemishes making it unbootable by the time I came to need it, so I threw it away) I can see that simpler provision of hardware drivers could speed adoption of a broader selection of  hardware platforms and operating systems.

It remains to been seen to what degree adoption on the wrong terms, i.e. without free software rights, is harmful. If more open source drivers follows the borader consumer adoption, it is maybe beneficial; I’m not yet at the level of Stallman where I can say "free software or no software" - I like my nvidia drivers, although I really wish they were free.

I’m just hoping that B# drivers would require enough meta data to link to make decompilation easy, I do want my source and the ability to fix bugs.

Which might mean that B# is just a glitzy gadget and for the kernel, a bad idea after all.

XSLT Hex to Decimal Conversion

Here’s a trick I came up with to convert some XML values from hex to decimal.

I made clever (awful?) use of substring-after and substring-before and a string-based lookup table.

Very nasty, but with whats available, very neat:

  <!-- output $hexNumber as decimal, recursive so not too many digits please... -->
  <xsl:template name="HexToDecimal">
    <xsl:param name="hexNumber" />
    <xsl:param name="decimalNumber" >0</xsl:param>
    <!– If there is zero hex digits left, output –>
    <xsl:choose>
      <xsl:when test="$hexNumber">
        <xsl:call-template name="HexToDecimal">
          <xsl:with-param name="decimalNumber" select="($decimalNumber*16)+number(substring-before(substring-after(’00/11/22/33/44/55/66/77/88/99/A10/B11/C12/D13/E14/F15/a10/b11/c12/d13/e14/f15/’,substring($hexNumber,1,1)),’/'))" />
          <xsl:with-param name="hexNumber" select="substring($hexNumber,2)" />
        </xsl:call-template>
      </xsl:when>
      <!– otherwise multiply, and add the next digit, and recurse –>
      <xsl:otherwise>
        <xsl:value-of select="$decimalNumber"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>
  <!– If it begins with 0x then parse it for sure, else return it –>
  <xsl:template name="asDecimal">
    <xsl:param name="number" />
    <xsl:choose>
      <xsl:when test="substring($number,1,2)=’0x’">
        <xsl:call-template name="HexToDecimal">
          <xsl:with-param name="hexNumber" select="substring($number,3)"/>
        </xsl:call-template>
      </xsl:when>
      <xsl:otherwise>
        <xsl:value-of select="$number"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>

Invoke with
  <xsl:call-template name="HexToDecimal">
    <xsl:with-param name="hexNumber" select="@hexValueAttribute"/>
  </xsl:call-template>

Or some such