/** push bytes back, to be read again later. */
private void pushback(byte[] bytes, int len) {
if (pushbackBufferLen == 0) {
pushbackBuffer = bytes; // TODO: copy?
pushbackBufferLen = len;
pushbackBufferOffset = 0;
} else {
final byte[] newPushbackBuffer = new byte[pushbackBufferLen + len];
System.arraycopy(pushbackBuffer, 0, newPushbackBuffer, 0, pushbackBufferLen);
System.arraycopy(bytes, 0, newPushbackBuffer, pushbackBufferLen, len);
pushbackBuffer = newPushbackBuffer;
pushbackBufferLen = pushbackBufferLen + len;
pushbackBufferOffset = 0;
}
}
/**
* Copies the content of the most recently received packet into <tt>data</tt>.
*
* @param buffer an optional <tt>Buffer</tt> instance associated with the specified <tt>data</tt>,
* <tt>offset</tt> and <tt>length</tt> and provided to the method in case the implementation
* would like to provide additional <tt>Buffer</tt> properties such as <tt>flags</tt>
* @param data the <tt>byte[]</tt> that we'd like to copy the content of the packet to.
* @param offset the position where we are supposed to start writing in <tt>data</tt>.
* @param length the number of <tt>byte</tt>s available for writing in <tt>data</tt>.
* @return the number of bytes read
* @throws IOException if <tt>length</tt> is less than the size of the packet.
*/
protected int read(Buffer buffer, byte[] data, int offset, int length) throws IOException {
if (data == null) throw new NullPointerException("data");
if (ioError) return -1;
RawPacket pkt;
synchronized (pktSyncRoot) {
pkt = this.pkt;
this.pkt = null;
}
int pktLength;
if (pkt == null) {
pktLength = 0;
} else {
// By default, pkt will be returned to the pool after it was read.
boolean poolPkt = true;
try {
pktLength = pkt.getLength();
if (length < pktLength) {
/*
* If pkt is still the latest RawPacket made available to
* reading, reinstate it for the next invocation of read;
* otherwise, return it to the pool.
*/
poolPkt = false;
throw new IOException("Input buffer not big enough for " + pktLength);
} else {
byte[] pktBuffer = pkt.getBuffer();
if (pktBuffer == null) {
throw new NullPointerException(
"pkt.buffer null, pkt.length " + pktLength + ", pkt.offset " + pkt.getOffset());
} else {
System.arraycopy(pkt.getBuffer(), pkt.getOffset(), data, offset, pktLength);
if (buffer != null) buffer.setFlags(pkt.getFlags());
}
}
} finally {
if (!poolPkt) {
synchronized (pktSyncRoot) {
if (this.pkt == null) this.pkt = pkt;
else poolPkt = true;
}
}
if (poolPkt) {
// Return pkt to the pool because it was successfully read.
poolRawPacket(pkt);
}
}
}
return pktLength;
}
public int write(byte[] buffer, int offset, int length, boolean transform) {
RawPacket pkt = rawPacketArray[0];
if (pkt == null) pkt = new RawPacket();
rawPacketArray[0] = pkt;
byte[] pktBuf = pkt.getBuffer();
if (pktBuf == null || pktBuf.length < length) {
pktBuf = new byte[length];
pkt.setBuffer(pktBuf);
}
System.arraycopy(buffer, offset, pktBuf, 0, length);
pkt.setOffset(0);
pkt.setLength(length);
if (transform) {
PacketTransformer packetTransformer =
isControlStream ? rtcpPacketTransformer : rtpPacketTransformer;
if (packetTransformer != null)
rawPacketArray = packetTransformer.reverseTransform(rawPacketArray);
}
SourceTransferHandler transferHandler;
PushSourceStream pushSourceStream;
try {
if (isControlStream) {
transferHandler = controlTransferHandler;
pushSourceStream = getControlInputStream();
} else {
transferHandler = dataTransferHandler;
pushSourceStream = getDataInputStream();
}
} catch (IOException ioe) {
throw new UndeclaredThrowableException(ioe);
}
for (int i = 0; i < rawPacketArray.length; i++) {
RawPacket packet = rawPacketArray[i];
// keep the first element for reuse
if (i != 0) rawPacketArray[i] = null;
if (packet != null) {
if (isControlStream) pendingControlPacket = packet;
else pendingDataPacket = packet;
if (transferHandler != null) {
transferHandler.transferData(pushSourceStream);
}
}
}
return length;
}
/** supports pushback. */
private int read(byte[] buffer, int offset, int length) throws IOException {
if (pushbackBufferLen > 0) { // read from pushback buffer
final int lenToCopy = length < pushbackBufferLen ? length : pushbackBufferLen;
System.arraycopy(pushbackBuffer, pushbackBufferOffset, buffer, offset, lenToCopy);
pushbackBufferLen -= lenToCopy;
pushbackBufferOffset += lenToCopy;
return lenToCopy;
} else {
return stream.read(buffer, offset, length);
}
}
/**
* Adds a <tt>DatagramPacketFilter</tt> which allows dropping <tt>DatagramPacket</tt>s before they
* are converted into <tt>RawPacket</tt>s.
*
* @param datagramPacketFilter the <tt>DatagramPacketFilter</tt> which allows dropping
* <tt>DatagramPacket</tt>s before they are converted into <tt>RawPacket</tt>s
*/
public synchronized void addDatagramPacketFilter(DatagramPacketFilter datagramPacketFilter) {
if (datagramPacketFilter == null) throw new NullPointerException("datagramPacketFilter");
if (datagramPacketFilters == null) {
datagramPacketFilters = new DatagramPacketFilter[] {datagramPacketFilter};
} else {
final int length = datagramPacketFilters.length;
for (int i = 0; i < length; i++)
if (datagramPacketFilter.equals(datagramPacketFilters[i])) return;
DatagramPacketFilter[] newDatagramPacketFilters = new DatagramPacketFilter[length + 1];
System.arraycopy(datagramPacketFilters, 0, newDatagramPacketFilters, 0, length);
newDatagramPacketFilters[length] = datagramPacketFilter;
datagramPacketFilters = newDatagramPacketFilters;
}
}
@Override
public int read(byte[] buffer, int offset, int length) throws IOException {
RawPacket pendingPacket;
if (isControlStream) {
pendingPacket = pendingControlPacket;
} else {
pendingPacket = pendingDataPacket;
}
int bytesToRead = 0;
byte[] pendingPacketBuffer = pendingPacket.getBuffer();
if (pendingPacketBuffer != null) {
int pendingPacketLength = pendingPacket.getLength();
bytesToRead = length > pendingPacketLength ? pendingPacketLength : length;
System.arraycopy(
pendingPacketBuffer, pendingPacket.getOffset(), buffer, offset, bytesToRead);
}
return bytesToRead;
}
/**
* Creates the video advanced settings.
*
* @return video advanced settings panel.
*/
private static Component createVideoAdvancedSettings() {
ResourceManagementService resources = NeomediaActivator.getResources();
final DeviceConfiguration deviceConfig = mediaService.getDeviceConfiguration();
TransparentPanel centerPanel = new TransparentPanel(new GridBagLayout());
centerPanel.setMaximumSize(new Dimension(WIDTH, 150));
JButton resetDefaultsButton =
new JButton(resources.getI18NString("impl.media.configform.VIDEO_RESET"));
JPanel resetButtonPanel = new TransparentPanel(new FlowLayout(FlowLayout.RIGHT));
resetButtonPanel.add(resetDefaultsButton);
final JPanel centerAdvancedPanel = new TransparentPanel(new BorderLayout());
centerAdvancedPanel.add(centerPanel, BorderLayout.NORTH);
centerAdvancedPanel.add(resetButtonPanel, BorderLayout.SOUTH);
GridBagConstraints constraints = new GridBagConstraints();
constraints.fill = GridBagConstraints.HORIZONTAL;
constraints.anchor = GridBagConstraints.NORTHWEST;
constraints.insets = new Insets(5, 5, 0, 0);
constraints.gridx = 0;
constraints.weightx = 0;
constraints.weighty = 0;
constraints.gridy = 0;
centerPanel.add(
new JLabel(resources.getI18NString("impl.media.configform.VIDEO_RESOLUTION")), constraints);
constraints.gridy = 1;
constraints.insets = new Insets(0, 0, 0, 0);
final JCheckBox frameRateCheck =
new SIPCommCheckBox(resources.getI18NString("impl.media.configform.VIDEO_FRAME_RATE"));
centerPanel.add(frameRateCheck, constraints);
constraints.gridy = 2;
constraints.insets = new Insets(5, 5, 0, 0);
centerPanel.add(
new JLabel(resources.getI18NString("impl.media.configform.VIDEO_PACKETS_POLICY")),
constraints);
constraints.weightx = 1;
constraints.gridx = 1;
constraints.gridy = 0;
constraints.insets = new Insets(5, 0, 0, 5);
Object[] resolutionValues = new Object[DeviceConfiguration.SUPPORTED_RESOLUTIONS.length + 1];
System.arraycopy(
DeviceConfiguration.SUPPORTED_RESOLUTIONS,
0,
resolutionValues,
1,
DeviceConfiguration.SUPPORTED_RESOLUTIONS.length);
final JComboBox sizeCombo = new JComboBox(resolutionValues);
sizeCombo.setRenderer(new ResolutionCellRenderer());
sizeCombo.setEditable(false);
centerPanel.add(sizeCombo, constraints);
// default value is 20
final JSpinner frameRate = new JSpinner(new SpinnerNumberModel(20, 5, 30, 1));
frameRate.addChangeListener(
new ChangeListener() {
public void stateChanged(ChangeEvent e) {
deviceConfig.setFrameRate(
((SpinnerNumberModel) frameRate.getModel()).getNumber().intValue());
}
});
constraints.gridy = 1;
constraints.insets = new Insets(0, 0, 0, 5);
centerPanel.add(frameRate, constraints);
frameRateCheck.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (frameRateCheck.isSelected()) {
deviceConfig.setFrameRate(
((SpinnerNumberModel) frameRate.getModel()).getNumber().intValue());
} else // unlimited framerate
deviceConfig.setFrameRate(-1);
frameRate.setEnabled(frameRateCheck.isSelected());
}
});
final JSpinner videoMaxBandwidth =
new JSpinner(
new SpinnerNumberModel(deviceConfig.getVideoMaxBandwidth(), 1, Integer.MAX_VALUE, 1));
videoMaxBandwidth.addChangeListener(
new ChangeListener() {
public void stateChanged(ChangeEvent e) {
deviceConfig.setVideoMaxBandwidth(
((SpinnerNumberModel) videoMaxBandwidth.getModel()).getNumber().intValue());
}
});
constraints.gridx = 1;
constraints.gridy = 2;
constraints.insets = new Insets(0, 0, 5, 5);
centerPanel.add(videoMaxBandwidth, constraints);
resetDefaultsButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
// reset to defaults
sizeCombo.setSelectedIndex(0);
frameRateCheck.setSelected(false);
frameRate.setEnabled(false);
frameRate.setValue(20);
// unlimited framerate
deviceConfig.setFrameRate(-1);
videoMaxBandwidth.setValue(DeviceConfiguration.DEFAULT_VIDEO_MAX_BANDWIDTH);
}
});
// load selected value or auto
Dimension videoSize = deviceConfig.getVideoSize();
if ((videoSize.getHeight() != DeviceConfiguration.DEFAULT_VIDEO_HEIGHT)
&& (videoSize.getWidth() != DeviceConfiguration.DEFAULT_VIDEO_WIDTH))
sizeCombo.setSelectedItem(deviceConfig.getVideoSize());
else sizeCombo.setSelectedIndex(0);
sizeCombo.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
Dimension selectedVideoSize = (Dimension) sizeCombo.getSelectedItem();
if (selectedVideoSize == null) {
// the auto value, default one
selectedVideoSize =
new Dimension(
DeviceConfiguration.DEFAULT_VIDEO_WIDTH,
DeviceConfiguration.DEFAULT_VIDEO_HEIGHT);
}
deviceConfig.setVideoSize(selectedVideoSize);
}
});
frameRateCheck.setSelected(
deviceConfig.getFrameRate() != DeviceConfiguration.DEFAULT_VIDEO_FRAMERATE);
frameRate.setEnabled(frameRateCheck.isSelected());
if (frameRate.isEnabled()) frameRate.setValue(deviceConfig.getFrameRate());
return centerAdvancedPanel;
}