“去隔行” Scala 中的列表

Question

我有一个字节列表，表示从音频接口读取的原始样本。根据用例和硬件，每个样本的长度可以是 1 到 4 个字节，并且“流”中的通道总数可以或多或少是任意的。每个样本的通道数量和位数在运行时都是已知的。

我将举一个例子来说明我的意思。流中有四个通道，每个样本是两个字节。

列表（A1，A2，B1，B2，C1，C2，D1，D2，A3，A4，B3，B4，C3，C4，D3，D4）

所以A1是通道A第一个样本的第一个字节，A2是同一样本的第二个字节，依此类推。

我需要做的是将每个通道的样本提取到自己的列表中，如下所示：

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

我将如何在惯用的 Scala 中做到这一点？我几个小时前刚刚开始学习 Scala，我想出的唯一非命令式解决方案显然不是最佳的：

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

但我不会

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

保证它的性能。我宁愿避免列表，不幸的是 grouped 产生它们。

也许

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

仍然有很多清单。

Answer 2

didierd 的 答案几乎是完美的，但是，唉，我认为可以稍微改进一下。他关心所有列表的创建，转置也是一个相当繁重的操作。如果您可以同时处理所有数据，那就足够了。

不过，我将使用 Stream，并使用一些小技巧来避免转置。

首先，分组是相同的，只是我将内容转换为流：

def getChannels[T](input: Iterator[T], elementsPerSample: Int, numOfChannels: Int) =
  input.toStream.grouped(elementsPerSample).toStream.grouped(numOfChannels).toStream

接下来，我将为您提供一个从中提取一个通道的函数：

def streamN[T](s: Stream[Stream[Stream[T]]])(channel: Int) = s flatMap (_(channel))

有了这些，我们可以解码流像这样：

// Sample input
val input = List('A1, 'A2, 'B1, 'B2, 'C1, 'C2, 'D1, 'D2, 'A3, 'A4, 'B3, 'B4, 'C3, 'C4, 'D3, 'D4)

// Save streams to val, to avoid recomputing the groups
val streams = getChannels(input.iterator, elementsPerSample = 2, numOfChannels = 4)

// Decode each one
def demuxer = streamN(streams) _
val aa = demuxer(0)
val bb = demuxer(1)
val cc = demuxer(2)
val dd = demuxer(3)

这将为每个通道返回单独的流而手头没有整个流。如果您需要实时处理输入，这可能很有用。这是一些输入源，用于测试它读取输入的深度以获取特定元素：

def source(elementsPerSample: Int, numOfChannels: Int) = Iterator.from(0).map { x =>
  "" + ('A' + x / elementsPerSample % numOfChannels).toChar +
  (x % elementsPerSample 
   + (x / (numOfChannels * elementsPerSample)) * elementsPerSample 
   + 1)
}.map { x => println("Saw "+x); x }

然后您可以尝试如下操作：

val streams = getChannels(source(2, 4), elementsPerSample = 2, numOfChannels = 4)
def demuxer = streamN(streams) _
val cc = demuxer(2)
println(cc take 20 toList)
val bb = demuxer(1)
println(bb take 30 toList)