private void passTcpFileDescriptor(
LocalSocket fdSocket,
OutputStream outputStream,
String socketId,
String dstIp,
int dstPort,
int connectTimeout)
throws Exception {
Socket sock = new Socket();
sock.setTcpNoDelay(true); // force file descriptor being created
if (protect(sock)) {
try {
sock.connect(new InetSocketAddress(dstIp, dstPort), connectTimeout);
ParcelFileDescriptor fd = ParcelFileDescriptor.fromSocket(sock);
tcpSockets.put(socketId, sock);
fdSocket.setFileDescriptorsForSend(new FileDescriptor[] {fd.getFileDescriptor()});
outputStream.write('*');
outputStream.flush();
fd.detachFd();
} catch (ConnectException e) {
LogUtils.e("connect " + dstIp + ":" + dstPort + " failed");
outputStream.write('!');
sock.close();
} catch (SocketTimeoutException e) {
LogUtils.e("connect " + dstIp + ":" + dstPort + " failed");
outputStream.write('!');
sock.close();
} finally {
outputStream.flush();
}
} else {
LogUtils.e("protect tcp socket failed");
}
}
// from Parcelable
public LibInfo(Parcel in) {
mLoadAddress = in.readLong();
mLoadSize = in.readLong();
mRelroStart = in.readLong();
mRelroSize = in.readLong();
ParcelFileDescriptor fd = in.readFileDescriptor();
mRelroFd = fd.detachFd();
}
private void passUdpFileDescriptor(
LocalSocket fdSocket, OutputStream outputStream, String socketId) throws Exception {
DatagramSocket sock = new DatagramSocket();
if (protect(sock)) {
ParcelFileDescriptor fd = ParcelFileDescriptor.fromDatagramSocket(sock);
udpSockets.put(socketId, sock);
fdSocket.setFileDescriptorsForSend(new FileDescriptor[] {fd.getFileDescriptor()});
outputStream.write('*');
outputStream.flush();
fd.detachFd();
} else {
LogUtils.e("protect udp socket failed");
}
}
/**
* Return the native fd int for this ParcelFileDescriptor and detach it from the object here. You
* are now responsible for closing the fd in native code.
*/
public int detachFd() {
if (mClosed) {
throw new IllegalStateException("Already closed");
}
if (mParcelDescriptor != null) {
int fd = mParcelDescriptor.detachFd();
mClosed = true;
return fd;
}
int fd = getFd();
mClosed = true;
Parcel.clearFileDescriptor(mFileDescriptor);
return fd;
}
@CalledByNative
private static boolean decodeAudioFile(
Context ctx, int nativeMediaCodecBridge, int inputFD, long dataSize) {
if (dataSize < 0 || dataSize > 0x7fffffff) return false;
MediaExtractor extractor = new MediaExtractor();
ParcelFileDescriptor encodedFD;
encodedFD = ParcelFileDescriptor.adoptFd(inputFD);
try {
extractor.setDataSource(encodedFD.getFileDescriptor(), 0, dataSize);
} catch (Exception e) {
e.printStackTrace();
encodedFD.detachFd();
return false;
}
if (extractor.getTrackCount() <= 0) {
encodedFD.detachFd();
return false;
}
MediaFormat format = extractor.getTrackFormat(0);
// Number of channels specified in the file
int inputChannelCount = format.getInteger(MediaFormat.KEY_CHANNEL_COUNT);
// Number of channels the decoder will provide. (Not
// necessarily the same as inputChannelCount. See
// crbug.com/266006.)
int outputChannelCount = inputChannelCount;
int sampleRate = format.getInteger(MediaFormat.KEY_SAMPLE_RATE);
String mime = format.getString(MediaFormat.KEY_MIME);
long durationMicroseconds = 0;
if (format.containsKey(MediaFormat.KEY_DURATION)) {
try {
durationMicroseconds = format.getLong(MediaFormat.KEY_DURATION);
} catch (Exception e) {
Log.d(LOG_TAG, "Cannot get duration");
}
}
if (DEBUG) {
Log.d(
LOG_TAG,
"Tracks: "
+ extractor.getTrackCount()
+ " Rate: "
+ sampleRate
+ " Channels: "
+ inputChannelCount
+ " Mime: "
+ mime
+ " Duration: "
+ durationMicroseconds
+ " microsec");
}
nativeInitializeDestination(
nativeMediaCodecBridge, inputChannelCount, sampleRate, durationMicroseconds);
// Create decoder
MediaCodec codec = MediaCodec.createDecoderByType(mime);
codec.configure(format, null /* surface */, null /* crypto */, 0 /* flags */);
codec.start();
ByteBuffer[] codecInputBuffers = codec.getInputBuffers();
ByteBuffer[] codecOutputBuffers = codec.getOutputBuffers();
// A track must be selected and will be used to read samples.
extractor.selectTrack(0);
boolean sawInputEOS = false;
boolean sawOutputEOS = false;
// Keep processing until the output is done.
while (!sawOutputEOS) {
if (!sawInputEOS) {
// Input side
int inputBufIndex = codec.dequeueInputBuffer(TIMEOUT_MICROSECONDS);
if (inputBufIndex >= 0) {
ByteBuffer dstBuf = codecInputBuffers[inputBufIndex];
int sampleSize = extractor.readSampleData(dstBuf, 0);
long presentationTimeMicroSec = 0;
if (sampleSize < 0) {
sawInputEOS = true;
sampleSize = 0;
} else {
presentationTimeMicroSec = extractor.getSampleTime();
}
codec.queueInputBuffer(
inputBufIndex,
0, /* offset */
sampleSize,
presentationTimeMicroSec,
sawInputEOS ? MediaCodec.BUFFER_FLAG_END_OF_STREAM : 0);
if (!sawInputEOS) {
extractor.advance();
}
}
}
// Output side
MediaCodec.BufferInfo info = new BufferInfo();
final int outputBufIndex = codec.dequeueOutputBuffer(info, TIMEOUT_MICROSECONDS);
if (outputBufIndex >= 0) {
ByteBuffer buf = codecOutputBuffers[outputBufIndex];
if (info.size > 0) {
nativeOnChunkDecoded(
nativeMediaCodecBridge, buf, info.size, inputChannelCount, outputChannelCount);
}
buf.clear();
codec.releaseOutputBuffer(outputBufIndex, false /* render */);
if ((info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
sawOutputEOS = true;
}
} else if (outputBufIndex == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
codecOutputBuffers = codec.getOutputBuffers();
} else if (outputBufIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
MediaFormat newFormat = codec.getOutputFormat();
outputChannelCount = newFormat.getInteger(MediaFormat.KEY_CHANNEL_COUNT);
Log.d(LOG_TAG, "output format changed to " + newFormat);
}
}
encodedFD.detachFd();
codec.stop();
codec.release();
codec = null;
return true;
}
