Question

I have a list of bytes that represent raw samples read in from an audio interface. Depending on the use case and H/W, each sample can be anywhere from 1 to 4 bytes long, and the total number of channels in the “stream” can be more or less arbitrary. The amount of channels and bits per sample are both known at runtime.

I’ll give an example of what I mean. There are four channels in the stream and each sample is two bytes.

List(A1, A2, B1, B2, C1, C2, D1, D2, A3, A4, B3, B4, C3, C4, D3, D4)

so A1 is the first byte of channel A‘s first sample, A2 is the second byte of the same sample and so on.

What I need to do is extract each channel’s samples into their own lists, like this:

List(List(A1, A2, A3, A4), List(B1, B2, B3, B4), List(C1, C2, C3, C4), List(D1, D2, D3, D4))

How would I go about doing this in idiomatic Scala? I just started learning Scala a few hours ago, and the only non-imperative solution I’ve come up with is clearly nonoptimal:

def uninterleave(samples: Array[Byte], numChannels: Int, bytesPerSample: Int) = {
val dropAmount = numChannels * bytesPerSample
  def extractChannel(n: Int) = {
    def extrInner(in: Seq[Byte], acc: Seq[Byte]): Seq[Byte] = {
      if(in == List()) acc
      else extrInner(in.drop(dropAmount), in.take(bytesPerSample) ++ acc)
    }
    extrInner(samples.drop(n * bytesPerSample), Nil)
  }

  for(i <- 0 until numChannels) yield extractChannel(i)
}

Answer 1

I would do

samples.grouped(bytesPerSample).grouped(numChannels).toList
  .transpose.map(_.flatten)

I would not vouch for its performance though. I would rather avoid lists, unfortunately grouped produces them.

Maybe

samples.grouped(bytesPerSample).map(_.toArray)
  .grouped(numChannels).map(_.toArray)
  .toArray
  .transpose
  .map(flatten)

Still, lots of lists.