Question

我有一个字节列表，表示从音频接口读入的原始样本。根据使用情况和H / W，每个样本可以是1到4个字节长的任何地方，并且“流”中的信道总数可以或多或少是任意的。每个样本的通道数和位数在运行时都是已知的。

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

List(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的answer只是完美的，但是，唉，我认为可以改善它。他关注所有列表创建，并且转置也是一个相当繁重的操作。如果您可以同时处理所有数据，那么它可能就足够了。

但是，我要使用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)

Scala中的“逐行扫描”列表

2 个答案: