private void store(AudioFrame frame, int index, int frameOffset, int frameLength) { ReferenceMutableAudioFrame targetFrame = frames[index]; targetFrame.setTimecode(frame.getTimecode()); targetFrame.setVolume(frame.getVolume()); targetFrame.setDataReference(frameBuffer, frameOffset, frameLength); frame.getData(frameBuffer, frameOffset); frameCount++; }
private void popFrame(MutableAudioFrame targetFrame) { ReferenceMutableAudioFrame frame = frames[firstFrame]; if (frame.getVolume() == 0) { silentFrame.setTimecode(frame.getTimecode()); frame = silentFrame; } targetFrame.setTimecode(frame.getTimecode()); targetFrame.setVolume(frame.getVolume()); targetFrame.setTerminator(false); targetFrame.store(frame.getFrameBuffer(), frame.getFrameOffset(), frame.getDataLength()); firstFrame = wrappedFrameIndex(firstFrame + 1); frameCount--; }
@Override public AudioFrame provide() { AudioFrame frame = frameBuffer.provide(); processProvidedFrame(frame); return frame; }
private boolean passToMutable(AudioFrame frame, MutableAudioFrame targetFrame) { if (targetFrame != null) { if (frame.isTerminator()) { targetFrame.setTerminator(true); } else { targetFrame.setTimecode(frame.getTimecode()); targetFrame.setVolume(frame.getVolume()); targetFrame.store(frame.getData(), 0, frame.getDataLength()); targetFrame.setTerminator(false); } return true; } return false; }
private AudioFrame unwrapBridgeFrame() { if (bridgeFrame.isTerminator()) { return TerminatorAudioFrame.INSTANCE; } else { return new ImmutableAudioFrame(bridgeFrame.getTimecode(), bridgeFrame.getData(), bridgeFrame.getVolume(), bridgeFrame.getFormat()); } }
private void passThrough(ByteBuffer buffer) throws InterruptedException { offeredFrame.setTimecode(currentTimecode); offeredFrame.setBuffer(buffer); context.frameBuffer.consume(offeredFrame); }
@Override public AudioFrame provide() { synchronized (synchronizer) { if (provide(getBridgeFrame())) { return unwrapBridgeFrame(); } return null; } }
@Override public boolean provide(MutableAudioFrame targetFrame, long timeout, TimeUnit unit) throws TimeoutException, InterruptedException { return passToMutable(provide(timeout, unit), targetFrame); }
@Override public Long getLastInputTimecode() { synchronized (synchronizer) { if (!clearOnInsert && frameCount > 0) { return frames[wrappedFrameIndex(firstFrame + frameCount - 1)].getTimecode(); } } return null; }
/** * @return An immutable instance created from this mutable audio frame. In an ideal flow, this should never be called. */ public ImmutableAudioFrame freeze() { return new ImmutableAudioFrame(timecode, getData(), volume, format); } }
private static ReferenceMutableAudioFrame[] createFrames(int frameCount, AudioDataFormat format) { ReferenceMutableAudioFrame[] frames = new ReferenceMutableAudioFrame[frameCount]; for (int i = 0; i < frames.length; i++) { frames[i] = new ReferenceMutableAudioFrame(); frames[i].setFormat(format); } return frames; }
/** * Wait until all the frames from the frame buffer have been consumed. Keeps the buffering thread alive to keep it * interruptible for seeking until buffer is empty. * * @throws InterruptedException When interrupted externally (or for seek/stop). */ public void waitOnEnd() throws InterruptedException { frameBuffer.setTerminateOnEmpty(); frameBuffer.waitForTermination(); }
@Override public byte[] getData() { byte[] data = new byte[getDataLength()]; getData(data, 0); return data; }
private void popPendingTerminator(MutableAudioFrame frame) { terminateOnEmpty = false; terminated = true; frame.setTerminator(true); }
@Override public byte[] getData() { byte[] data = new byte[frameLength]; getData(data, 0); return data; }
@Override public AudioFrame provide(long timeout, TimeUnit unit) throws TimeoutException, InterruptedException { synchronized (synchronizer) { if (provide(getBridgeFrame(), timeout, unit)) { return unwrapBridgeFrame(); } return null; } }
@Override public boolean provide(MutableAudioFrame targetFrame, long timeout, TimeUnit unit) throws TimeoutException, InterruptedException { if (frameBuffer.provide(targetFrame, timeout, unit)) { processProvidedFrame(targetFrame); return true; } return true; }
@Override public boolean provide(MutableAudioFrame targetFrame) { return passToMutable(provide(), targetFrame); }
@Override public AudioFrame provide(long timeout, TimeUnit unit) throws TimeoutException, InterruptedException { AudioFrame frame = frameBuffer.provide(timeout, unit); processProvidedFrame(frame); return frame; }
@Override public boolean provide(MutableAudioFrame targetFrame) { if (frameBuffer.provide(targetFrame)) { processProvidedFrame(targetFrame); return true; } return false; }