Philippe Strauss website (Posts about Programming)

A 30 SLOC CLI native code sound file player

Philippe Strauss — Wed, 28 Aug 2024 13:14:57 GMT

Here is a short, approximatively 30 SLOC OCaml code to play a soundfile through Jack or Pipewire. I like tidy, simple, straight to the point code and languages, minimizing the number of SLOC to achieve a given task, but still compiled to native code with a serious, highly bug-screening compilation process. Ocaml ideally fits the bill here, but a garbage collector based language does not makes things easy regarding real-time constraints. We use ocaml-bjack, which buffers sound I/O and we give half a second of buffering to shield us from the GC runtime.

First lets open the soundfile using ocaml-libsndfile and query the number of channels and samplerate of the file:

let () =
    let soundfile = Sys.argv.(1) in
    let sf = Sndfile.openfile soundfile in
    let nchan = Sndfile.channels sf in
    let sfreq = Sndfile.samplerate sf in
    Printf.printf "Opened sound file %s.\n%!" soundfile ;

Next we start our Jack client and indicate a one second depth buffer (sfreq*nchan) for I/O of which we'll use half:

    Bjack.set_conversion_function Bjack.Best_quality ;
    let bjk = Bjack.open_t ~rate:sfreq ~bits_per_sample:16 ~input_channels:0 ~output_channels:nchan
        ~flags:[ Bjack.Output ] ~client_name:"sfplay" ~ringbuffer_size:(sfreq*nchan) () in
    Printf.printf "Opened JACK audio device.\n%!" ;

Now define a buffer for passing data from libsndfile to jack:

    let buflen = 1024 in (* samples per channel *)
    let inlen = buflen * nchan in
    let interleaved = Array.make inlen 0. in

More interestening, we receive data from libsndfile in a normalized to ]-1.0; +1.0] stream of floating point values, while ocaml-bjack accept samples in a stream of 16bit integers encoded in a string. The function short_from_float takes a float, amplify it by 32768 and return a pair of values bounded by [0; 255], ready to be encoded as characters in a string. Next the function paircat takes as input an Array of such pairs and build a string representing a flow of samples using a fold.

    let short_from_float input =
        let inint = int_of_float (32768. *. input) in
        let lower = inint land 0xff in
        let upper = (inint land 0xff00) lsr 8 in
        (upper, lower) in
    let paircat s cp =
        s ^ String.make 1 (Char.chr (snd cp)) ^ String.make 1 (Char.chr (fst cp)) in

Note that the caret means string concatenation and Char.chr return a character out of its integer index in the 8bit ASCII table, while fst and snd return the first and second in a pair, respectively. We then define a pause time half the time to sink a buflen buffer:

    let pausetime = (float_of_int buflen) /. (2. *. float_of_int sfreq) in

We start the processing loop until an indication there is nothing more to read from the soundfile:

    let read = ref 1 in
    while !read > 0 do
        if Bjack.get_bytes_stored bjk < sfreq*nchan/2 then (

Here is the main processing of this program, we read the soundfile buflen*nchan at a time, use Array.map and fold_left to convert our floats to a string, and write this string in the Jack ringbuffer:

            read := Sndfile.read sf interleaved ;
            let pairs = Array.map (fun x -> short_from_float x) interleaved in
            let shorts = Array.fold_left paircat "" pairs in
            ignore(Bjack.write bjk shorts)

When enough data is in the Jack ringbuffer, we simply idle doing nothing, for a time long enough to empty a bit over one buflen*nchan in the Jack ringbuffer. Note that using map and fold here imply allocating and collecting arrays of memory inside the tight processing loop, this is not an ideal way of writing a soft real-time program. It can be seen by looking at the CPU usage, something suboptimal is going on (the reccuring, high frequency memory allocation of relatively large arrays). This is a short tutorial only, but shows that OCaml, even used far from its design goal (the Coq theorem prover implementation language) is still able to cope with basics multimedia requirements. It happens, computers history shows, that OCaml has ended as being a broad, expressive general purpose programming language.

        ) else Unix.sleepf (3.*.pausetime) ;
        Printf.printf "Bjack.get_bytes_stored=%d\r%!" (Bjack.get_bytes_stored bjk)
    done ;
    Bjack.close bjk

That's it, a little starter dish in OCaml with more than a "Hello world" or a fibonacci, for peoples having other simpler language as a background.

OCaml: the choice of discriminating hackers

Philippe Strauss — Sat, 31 Dec 2011 23:00:00 GMT

Discriminating: in the first sense: 1a. Able to recognize or draw fine distinctions; perceptive. 1b. Showing careful judgment or fine taste :-)

Hacker: computer programming enthusiast, not security breaking fanatic.

Why OCaml?

I became interested, intrigued by this langage a long while back, in 2000-2002, when seeing it score rank second or third, just behind C and C++, on the computer language shootout hosted on alioth.debian.org. Never really invested a lot of time learning it before 2007-2008. It's not the easiest language for beginners, beeing a toolbox with a lot of tools, each having at least one distinctive name and functionality on it. Most peoples tends to prefer simple things, especially when it come to programming, where the overall picture, the frameworks, libraries, OS surrounding your development can quickly grow in becoming a big beast to harness.

Pure javascript HTML5 canvas bilinear image interpolation

Philippe Strauss — Sat, 31 Dec 2011 23:00:00 GMT

I've finally got my finger on a motivating javascript tryout. Never went deep into web programming before, this is the first full day of my life spent on JS. I wanted to test the feasibility (in term of computation time spent by the browser) of good quality image interpolation solely on the client side, in javascript. Even on a mac air 1.4GHz, it turns out to be a perfectly viable solution.

Googling to find some existing code, I didn't find any valuable. So here is one, it's working for me, not just a half baked solution computing only one pixel in the image and approximatively. The following HTML+JS is self contained and works fine, at least on my setup.

Zölzer-Boltze (ZB) peak/notch parametric EQ in C

Philippe Strauss — Sun, 14 Aug 2011 22:00:00 GMT

For digital audio signal processing

I was looking for a good implementation of parametric EQ for digital audio, didn't find something valuable enough, so I needed to roll my own. I retained a paper by two german guys, Mrs. Zölzer and Boltze, and implemented it.

It has the best parameters independance of all the one I browsed through. Well, center frequency, Q factor and cut/boost gain are simply really independant in their work, contrary to a lot of such projects you will find while googling around.

FIR filter design experiment using the simplex method

Philippe Strauss — Tue, 31 Aug 2010 23:00:00 GMT

A starter about symetrical (linear phase) finite impulse response digital filter design using the simplex method. Much slower than Parks/McClellan/Remez exchange, but packaged in GLPK. 75 lines of OCaml code to design an FIR filter, what less could you ask for ?

The paper to have in hands is the "Meteor" one by Steiglitz. In short, from a vector dot matrix multiplication, we get the frequency response. The matrix beeing a cosine table, the vector beeing the filter coefficients.

The simplex method beeing a relatively simple optimization procedure for linear problems.

Backing up and archiving Cisco IOS/ASA configurations live from the router without TFTP

Philippe Strauss — Sat, 31 May 2008 23:00:00 GMT

In Python and with Subversion archiving

At some point as a network admin, I did find easier to parse config file using python expect and some regexp, rather than relying on the unreliable TFTP. Here's a script which worked fine for one year or so. It also does automate archiving in subversion. It's delibaretly in a shape suitable for a blog page, working after tuning two paths in the first script, but without a tarball and 12 pages of doco. Python is simple enough to read and understand even for peoples having never learned this language.