1

（我试图让我之前的问题更通用，以期获得解决方案。）

我正在使用 JLayer 库和 sample.mp3 文件。我想同时播放和解码文件。

但是，我希望它们同步 - 如果歌曲的一部分被解码，它也会被播放。在播放之前没有任何内容被解码，反之亦然（当然，在合理的程度上）。

以下是歌曲的播放和解码方式，恭敬地：

Player p = new Player(InputStream mp3stream);
p.play();

Decoder d = new Decoder();
BitStream bs = new Bitstream(InputStream mp3stream);
SampleBuffer s = (SampleBuffer) d.decodeFrame(bs.readFrame(), bs);
// ... for processing the SampleBuffer but irrelevant for the question

我目前使用：

InputStream mp3stream = new FileInputStream("sample.mp3");

但这一次使用了整首歌曲，所以我无法同步。有没有办法将 sample.mp3 分解成两个进程都可以操作的片段？如果我有足够小的碎片，我可以将两个碎片都运行到流程中，等到两个都完成，然后抓住下一个小碎片并重复，直到我用完小碎片。

注意：我尝试使用 ByteArrayInputStream 没有成功 - 但使用它时我的方法可能不正确。

4

1 回答 1

1

我希望我做对了：

  • 你有一个输入文件
  • 您希望两个不同的输入流在某种意义上是同步的，即“它们必须在流中取得相同的进展”。

这是一个有趣的问题。我想出了下面的草图（编译，但没有执行它，所以你可以先做一些测试）。

  • 创建一个包装对象“StreamSynchronizer”来控制对底层输入的访问。只有一个字节被读取，直到所有派生流都读取了这个字节。
  • 从中派生任意数量的“SynchronizedStream”实例，将“读取”委托回 StreamSynchronizer。

package de.mit.stackoverflow;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class StreamSynchronizer {

    final private InputStream inputStream;

    private List activeStreams = new ArrayList();

    private int lastByte;

    private Set waitingStreams = new HashSet();

    private Object lock = new Object();

    public StreamSynchronizer(InputStream is) throws IOException {
        super();
        this.inputStream = is;
        lastByte = getInputStream().read();
    }

    public void close(SynchronizedStream stream) {
        activeStreams.remove(stream);
    }

    public SynchronizedStream createStream() {
        SynchronizedStream stream = new SynchronizedStream(this);
        activeStreams.add(stream);
        return stream;
    }

    public InputStream getInputStream() {
        return inputStream;
    }

    public int read(SynchronizedStream stream) throws IOException {
        synchronized (lock) {
            while (waitingStreams.contains(stream)) {
                if (waitingStreams.size() == activeStreams.size()) {
                    waitingStreams.clear();
                    lastByte = getInputStream().read();
                    lock.notifyAll();
                } else {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        throw new IOException(e);
                    }
                }
            }
            waitingStreams.add(stream);
            return lastByte;
        }
    }
}



package de.mit.stackoverflow;

import java.io.IOException;
import java.io.InputStream;

public class SynchronizedStream extends InputStream {

    final private StreamSynchronizer synchronizer;

    protected SynchronizedStream(StreamSynchronizer synchronizer) {
        this.synchronizer = synchronizer;
    }

    @Override
    public void close() throws IOException {
        getSynchronizer().close(this);
    }

    public StreamSynchronizer getSynchronizer() {
        return synchronizer;
    }

    @Override
    public int read() throws IOException {
        return getSynchronizer().read(this);
    }
}

于 2011-01-04T10:11:56.763 回答