JLayer 동기화

Question

(I 해결책의 희망에 내 앞의 질문이 더 일반적인을 시도하고있다.)

나는 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을 사용해 보았는데 성공하지 못했습니다. 그러나 사용하는 방법이 잘못되었을 수 있습니다.

Answer 1

나는 내가이 제대로 희망 :

• 당신은 하나의 입력 파일이을에서 "그들은 같은 진행을해야합니다"당신이 두 개의 서로 다른 입력 스트림 의미에서 동기화되도록 할
• , 흐름.

이것은 흥미로운 질문입니다. 나는 다음과 같은 스케치 (컴파일,하지만 그것을 실행하지 않았다, 그래서 당신은 약간의 테스트를 먼저 할 수 있습니다)를 생각해 냈습니다.

• 기본 입력에 대한 액세스를 제어하는 ​​래퍼 개체 "StreamSynchronizer"를 만듭니다. 모든 파생 스트림이이 바이트를 읽을 때까지 단일 바이트 만 읽습니다.
• StreamSynchronizer에 대한 "읽기"를 위임 한이 인스턴스에서 임의의 수의 "SynchronizedStream"인스턴스를 파생시킵니다.

 

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); 
    } 
}