/**
* Edits a video file, saving the contents to a new file. This involves decoding and re-encoding,
* not to mention conversions between YUV and RGB, and so may be lossy.
*
* <p>If we recognize the decoded format we can do this in Java code using the ByteBuffer[]
* output, but it's not practical to support all OEM formats. By using a SurfaceTexture for output
* and a Surface for input, we can avoid issues with obscure formats and can use a fragment shader
* to do transformations.
*/
private VideoChunks editVideoFile(VideoChunks inputData) {
if (VERBOSE) Log.d(TAG, "editVideoFile " + mWidth + "x" + mHeight);
VideoChunks outputData = new VideoChunks();
MediaCodec decoder = null;
MediaCodec encoder = null;
InputSurface inputSurface = null;
OutputSurface outputSurface = null;
try {
MediaFormat inputFormat = inputData.getMediaFormat();
// Create an encoder format that matches the input format. (Might be able to just
// re-use the format used to generate the video, since we want it to be the same.)
MediaFormat outputFormat = MediaFormat.createVideoFormat(MIME_TYPE, mWidth, mHeight);
outputFormat.setInteger(
MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
outputFormat.setInteger(
MediaFormat.KEY_BIT_RATE, inputFormat.getInteger(MediaFormat.KEY_BIT_RATE));
outputFormat.setInteger(
MediaFormat.KEY_FRAME_RATE, inputFormat.getInteger(MediaFormat.KEY_FRAME_RATE));
outputFormat.setInteger(
MediaFormat.KEY_I_FRAME_INTERVAL,
inputFormat.getInteger(MediaFormat.KEY_I_FRAME_INTERVAL));
outputData.setMediaFormat(outputFormat);
encoder = MediaCodec.createEncoderByType(MIME_TYPE);
encoder.configure(outputFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
inputSurface = new InputSurface(encoder.createInputSurface());
inputSurface.makeCurrent();
encoder.start();
// OutputSurface uses the EGL context created by InputSurface.
decoder = MediaCodec.createDecoderByType(MIME_TYPE);
outputSurface = new OutputSurface();
outputSurface.changeFragmentShader(FRAGMENT_SHADER);
decoder.configure(inputFormat, outputSurface.getSurface(), null, 0);
decoder.start();
editVideoData(inputData, decoder, outputSurface, inputSurface, encoder, outputData);
} finally {
if (VERBOSE) Log.d(TAG, "shutting down encoder, decoder");
if (outputSurface != null) {
outputSurface.release();
}
if (inputSurface != null) {
inputSurface.release();
}
if (encoder != null) {
encoder.stop();
encoder.release();
}
if (decoder != null) {
decoder.stop();
decoder.release();
}
}
return outputData;
}
// Dequeue and return an output buffer index, -1 if no output
// buffer available or -2 if error happened.
private DecoderOutputBufferInfo dequeueOutputBuffer(int dequeueTimeoutUs) {
checkOnMediaCodecThread();
try {
MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();
int result = mediaCodec.dequeueOutputBuffer(info, dequeueTimeoutUs);
while (result == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED
|| result == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
if (result == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
outputBuffers = mediaCodec.getOutputBuffers();
Logging.d(TAG, "Decoder output buffers changed: " + outputBuffers.length);
} else if (result == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
MediaFormat format = mediaCodec.getOutputFormat();
Logging.d(TAG, "Decoder format changed: " + format.toString());
width = format.getInteger(MediaFormat.KEY_WIDTH);
height = format.getInteger(MediaFormat.KEY_HEIGHT);
if (!useSurface && format.containsKey(MediaFormat.KEY_COLOR_FORMAT)) {
colorFormat = format.getInteger(MediaFormat.KEY_COLOR_FORMAT);
Logging.d(TAG, "Color: 0x" + Integer.toHexString(colorFormat));
// Check if new color space is supported.
boolean validColorFormat = false;
for (int supportedColorFormat : supportedColorList) {
if (colorFormat == supportedColorFormat) {
validColorFormat = true;
break;
}
}
if (!validColorFormat) {
Logging.e(TAG, "Non supported color format");
return new DecoderOutputBufferInfo(-1, 0, 0, -1);
}
}
if (format.containsKey("stride")) {
stride = format.getInteger("stride");
}
if (format.containsKey("slice-height")) {
sliceHeight = format.getInteger("slice-height");
}
Logging.d(TAG, "Frame stride and slice height: " + stride + " x " + sliceHeight);
stride = Math.max(width, stride);
sliceHeight = Math.max(height, sliceHeight);
}
result = mediaCodec.dequeueOutputBuffer(info, dequeueTimeoutUs);
}
if (result >= 0) {
return new DecoderOutputBufferInfo(result, info.offset, info.size, info.presentationTimeUs);
}
return null;
} catch (IllegalStateException e) {
Logging.e(TAG, "dequeueOutputBuffer failed", e);
return new DecoderOutputBufferInfo(-1, 0, 0, -1);
}
}
@SuppressLint("InlinedApi")
private void maybeSetMaxInputSize(android.media.MediaFormat format, boolean codecIsAdaptive) {
if (format.containsKey(android.media.MediaFormat.KEY_MAX_INPUT_SIZE)) {
// Already set. The source of the format may know better, so do nothing.
return;
}
int maxHeight = format.getInteger(android.media.MediaFormat.KEY_HEIGHT);
if (codecIsAdaptive && format.containsKey(android.media.MediaFormat.KEY_MAX_HEIGHT)) {
maxHeight = Math.max(maxHeight, format.getInteger(android.media.MediaFormat.KEY_MAX_HEIGHT));
}
int maxWidth = format.getInteger(android.media.MediaFormat.KEY_WIDTH);
if (codecIsAdaptive && format.containsKey(android.media.MediaFormat.KEY_MAX_WIDTH)) {
maxWidth = Math.max(maxHeight, format.getInteger(android.media.MediaFormat.KEY_MAX_WIDTH));
}
int maxPixels;
int minCompressionRatio;
switch (format.getString(android.media.MediaFormat.KEY_MIME)) {
case MimeTypes.VIDEO_H263:
case MimeTypes.VIDEO_MP4V:
maxPixels = maxWidth * maxHeight;
minCompressionRatio = 2;
break;
case MimeTypes.VIDEO_H264:
if ("BRAVIA 4K 2015".equals(Util.MODEL)) {
// The Sony BRAVIA 4k TV has input buffers that are too small for the calculated 4k video
// maximum input size, so use the default value.
return;
}
// Round up width/height to an integer number of macroblocks.
maxPixels = ((maxWidth + 15) / 16) * ((maxHeight + 15) / 16) * 16 * 16;
minCompressionRatio = 2;
break;
case MimeTypes.VIDEO_VP8:
// VPX does not specify a ratio so use the values from the platform's SoftVPX.cpp.
maxPixels = maxWidth * maxHeight;
minCompressionRatio = 2;
break;
case MimeTypes.VIDEO_H265:
case MimeTypes.VIDEO_VP9:
maxPixels = maxWidth * maxHeight;
minCompressionRatio = 4;
break;
default:
// Leave the default max input size.
return;
}
// Estimate the maximum input size assuming three channel 4:2:0 subsampled input frames.
int maxInputSize = (maxPixels * 3) / (2 * minCompressionRatio);
format.setInteger(android.media.MediaFormat.KEY_MAX_INPUT_SIZE, maxInputSize);
}
private void initStream() throws IOException, IllegalArgumentException {
L.v(TAG, "initStream called in state=" + state);
lock.lock();
try {
extractor = new MediaExtractor();
if (path != null) {
extractor.setDataSource(path);
} else {
error("initStream");
throw new IOException();
}
int trackNum = 0;
final MediaFormat oFormat = extractor.getTrackFormat(trackNum);
if (!oFormat.containsKey(MediaFormat.KEY_SAMPLE_RATE)) {
error("initStream");
throw new IOException("No KEY_SAMPLE_RATE");
}
int sampleRate = oFormat.getInteger(MediaFormat.KEY_SAMPLE_RATE);
if (!oFormat.containsKey(MediaFormat.KEY_CHANNEL_COUNT)) {
error("initStream");
throw new IOException("No KEY_CHANNEL_COUNT");
}
int channelCount = oFormat.getInteger(MediaFormat.KEY_CHANNEL_COUNT);
if (!oFormat.containsKey(MediaFormat.KEY_MIME)) {
error("initStream");
throw new IOException("No KEY_MIME");
}
final String mime = oFormat.getString(MediaFormat.KEY_MIME);
if (!oFormat.containsKey(MediaFormat.KEY_DURATION)) {
error("initStream");
throw new IOException("No KEY_DURATION");
}
duration = oFormat.getLong(MediaFormat.KEY_DURATION);
L.v(TAG, "Sample rate: " + sampleRate);
L.v(TAG, "Mime type: " + mime);
initDevice(sampleRate, channelCount);
extractor.selectTrack(trackNum);
codec = MediaCodec.createDecoderByType(mime);
codec.configure(oFormat, null, null, 0);
} finally {
lock.unlock();
}
}
public int getVideoWidth() {
return mVideoFormat != null
? (int)
(mVideoFormat.getInteger(MediaFormat.KEY_HEIGHT)
* mVideoFormat.getFloat(MediaExtractor.MEDIA_FORMAT_EXTENSION_KEY_DAR))
: 0;
}
/* */ public synchronized boolean a(String paramString) /* */ {
/* 362 */ a.a("playWAV start :" + paramString);
/* */
/* 364 */ if (!c(paramString)) {
/* 365 */ a.b("file not exist");
/* 366 */ return false;
/* */ }
/* */
/* 369 */ String str1 = paramString.trim();
/* 370 */ String str2 = str1.substring(str1.lastIndexOf(".") + 1);
/* 371 */ str2 = str2.toLowerCase();
/* 372 */ if (!str2.equalsIgnoreCase("wav")) {
/* 373 */ a.b("file not wav file");
/* 374 */ g();
/* 375 */ return false;
/* */ }
/* */
/* 378 */ MediaExtractor localMediaExtractor = null;
/* */ try {
/* 380 */ localMediaExtractor = new MediaExtractor();
/* */ } catch (RuntimeException localRuntimeException1) {
/* 382 */ localRuntimeException1.printStackTrace();
/* 383 */ a.b("MediaExtractor error");
/* */ }
/* */ try
/* */ {
/* 387 */ localMediaExtractor.setDataSource(paramString);
/* */ } catch (IOException localIOException) {
/* 389 */ localIOException.printStackTrace();
/* 390 */ a.b("setDataSource error");
/* 391 */ return false;
/* */ }
/* */
/* 394 */ MediaFormat localMediaFormat = null;
/* 395 */ int i1 = localMediaExtractor.getTrackCount();
/* 396 */ if (i1 > 0) {
/* */ try {
/* 398 */ localMediaFormat = localMediaExtractor.getTrackFormat(0);
/* */ } catch (RuntimeException localRuntimeException2) {
/* 400 */ localRuntimeException2.printStackTrace();
/* 401 */ a.b("getTrackFormat error");
/* 402 */ return false;
/* */ }
/* */
/* */
/* 406 */ int i2 = localMediaFormat.getInteger("sample-rate");
/* */
/* 408 */ this.j = localMediaFormat.getLong("durationUs");
/* */
/* 410 */ if (i2 < n) {
/* 411 */ g();
/* 412 */ return false;
/* */ }
/* */
/* 415 */ return PlayWav(paramString);
/* */ }
/* 417 */ return false;
/* */ }
void setup() {
int width = 0, height = 0;
extractor = new MediaExtractor();
try {
extractor.setDataSource(mVideoFile.getPath());
} catch (IOException e) {
return;
}
for (int i = 0; i < extractor.getTrackCount(); i++) {
MediaFormat format = extractor.getTrackFormat(i);
String mime = format.getString(MediaFormat.KEY_MIME);
width = format.getInteger(MediaFormat.KEY_WIDTH);
height = format.getInteger(MediaFormat.KEY_HEIGHT);
if (mime.startsWith("video/")) {
extractor.selectTrack(i);
try {
decoder = MediaCodec.createDecoderByType(mime);
} catch (IOException e) {
continue;
}
// Decode to surface
// decoder.configure(format, surface, null, 0);
// Decode to offscreen surface
surface = new CtsMediaOutputSurface(width, height);
mMatBuffer = new MatBuffer(width, height);
decoder.configure(format, surface.getSurface(), null, 0);
break;
}
}
if (decoder == null) {
Log.e("VideoDecoderForOpenCV", "Can't find video info!");
return;
}
valid = true;
}
@Override
protected void onOutputFormatChanged(MediaCodec codec, android.media.MediaFormat outputFormat) {
boolean hasCrop =
outputFormat.containsKey(KEY_CROP_RIGHT)
&& outputFormat.containsKey(KEY_CROP_LEFT)
&& outputFormat.containsKey(KEY_CROP_BOTTOM)
&& outputFormat.containsKey(KEY_CROP_TOP);
currentWidth =
hasCrop
? outputFormat.getInteger(KEY_CROP_RIGHT) - outputFormat.getInteger(KEY_CROP_LEFT) + 1
: outputFormat.getInteger(android.media.MediaFormat.KEY_WIDTH);
currentHeight =
hasCrop
? outputFormat.getInteger(KEY_CROP_BOTTOM) - outputFormat.getInteger(KEY_CROP_TOP) + 1
: outputFormat.getInteger(android.media.MediaFormat.KEY_HEIGHT);
currentPixelWidthHeightRatio = pendingPixelWidthHeightRatio;
if (Util.SDK_INT >= 21) {
// On API level 21 and above the decoder applies the rotation when rendering to the surface.
// Hence currentUnappliedRotation should always be 0. For 90 and 270 degree rotations, we need
// to flip the width, height and pixel aspect ratio to reflect the rotation that was applied.
if (pendingRotationDegrees == 90 || pendingRotationDegrees == 270) {
int rotatedHeight = currentWidth;
currentWidth = currentHeight;
currentHeight = rotatedHeight;
currentPixelWidthHeightRatio = 1 / currentPixelWidthHeightRatio;
}
} else {
// On API level 20 and below the decoder does not apply the rotation.
currentUnappliedRotationDegrees = pendingRotationDegrees;
}
// Must be applied each time the output format changes.
codec.setVideoScalingMode(videoScalingMode);
}
/**
* @param src_file
* @return first video track index, -1 if not found
*/
protected int internal_prepare_video(final String source_file) {
int trackindex = -1;
mVideoMediaExtractor = new MediaExtractor();
try {
mVideoMediaExtractor.setDataSource(source_file);
trackindex = selectTrack(mVideoMediaExtractor, "video/");
if (trackindex >= 0) {
mVideoMediaExtractor.selectTrack(trackindex);
final MediaFormat format = mVideoMediaExtractor.getTrackFormat(trackindex);
mVideoWidth = format.getInteger(MediaFormat.KEY_WIDTH);
mVideoHeight = format.getInteger(MediaFormat.KEY_HEIGHT);
mDuration = format.getLong(MediaFormat.KEY_DURATION);
if (DEBUG)
Log.v(
TAG,
String.format(
"format:size(%d,%d),duration=%d,bps=%d,framerate=%f,rotation=%d",
mVideoWidth, mVideoHeight, mDuration, mBitrate, mFrameRate, mRotation));
}
} catch (final IOException e) {
}
return trackindex;
}
public PassThroughTrackTranscoder(
MediaExtractor extractor,
int trackIndex,
QueuedMuxer muxer,
QueuedMuxer.SampleType sampleType) {
mExtractor = extractor;
mTrackIndex = trackIndex;
mMuxer = muxer;
mSampleType = sampleType;
mActualOutputFormat = mExtractor.getTrackFormat(mTrackIndex);
mMuxer.setOutputFormat(mSampleType, mActualOutputFormat);
mBufferSize = mActualOutputFormat.getInteger(MediaFormat.KEY_MAX_INPUT_SIZE);
mBuffer = ByteBuffer.allocateDirect(mBufferSize).order(ByteOrder.nativeOrder());
}
public int getVideoHeight() {
return mVideoFormat != null ? mVideoFormat.getInteger(MediaFormat.KEY_HEIGHT) : 0;
}
@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;
}
@Override
public void run() {
isDecoding = true;
codec.start();
@SuppressWarnings("deprecation")
ByteBuffer[] inputBuffers = codec.getInputBuffers();
@SuppressWarnings("deprecation")
ByteBuffer[] outputBuffers = codec.getOutputBuffers();
boolean sawInputEOS = false;
boolean sawOutputEOS = false;
while (!sawInputEOS && !sawOutputEOS && continuing) {
if (state == State.PAUSED) {
try {
synchronized (decoderLock) {
decoderLock.wait();
}
} catch (InterruptedException e) {
// Purposely not doing anything here
}
continue;
}
if (sonic != null) {
sonic.setSpeed(speed);
sonic.setPitch(1);
}
int inputBufIndex = codec.dequeueInputBuffer(200);
if (inputBufIndex >= 0) {
ByteBuffer dstBuf = inputBuffers[inputBufIndex];
int sampleSize = extractor.readSampleData(dstBuf, 0);
long presentationTimeUs = 0;
if (sampleSize < 0) {
sawInputEOS = true;
sampleSize = 0;
} else {
presentationTimeUs = extractor.getSampleTime();
}
codec.queueInputBuffer(
inputBufIndex,
0,
sampleSize,
presentationTimeUs,
sawInputEOS ? MediaCodec.BUFFER_FLAG_END_OF_STREAM : 0);
if (flushCodec) {
codec.flush();
flushCodec = false;
}
if (!sawInputEOS) {
extractor.advance();
}
}
final MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();
byte[] modifiedSamples = new byte[info.size];
int res;
//noinspection deprecation
do {
res = codec.dequeueOutputBuffer(info, 200);
if (res >= 0) {
final byte[] chunk = new byte[info.size];
outputBuffers[res].get(chunk);
outputBuffers[res].clear();
if (chunk.length > 0) {
sonic.writeBytesToStream(chunk, chunk.length);
} else {
sonic.flushStream();
}
int available = sonic.availableBytes();
if (available > 0) {
if (modifiedSamples.length < available) {
modifiedSamples = new byte[available];
}
sonic.readBytesFromStream(modifiedSamples, available);
track.write(modifiedSamples, 0, available);
}
codec.releaseOutputBuffer(res, false);
if ((info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
sawOutputEOS = true;
}
} else //noinspection deprecation
if (res == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
//noinspection deprecation
outputBuffers = codec.getOutputBuffers();
} else if (res == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
track.stop();
lock.lock();
try {
track.release();
final MediaFormat oFormat = codec.getOutputFormat();
initDevice(
oFormat.getInteger(MediaFormat.KEY_SAMPLE_RATE),
oFormat.getInteger(MediaFormat.KEY_CHANNEL_COUNT));
//noinspection deprecation
outputBuffers = codec.getOutputBuffers();
track.play();
} catch (IOException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
} while (res == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED
|| res == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED);
}
codec.stop();
track.stop();
isDecoding = false;
if (continuing && (sawInputEOS || sawOutputEOS)) {
state = State.PLAYBACK_COMPLETED;
L.d(TAG, "State changed to: " + state);
Thread t =
new Thread(
new Runnable() {
@Override
public void run() {
if (onCompletionListener != null) {
onCompletionListener.onCompletion();
}
stayAwake(false);
}
});
t.setDaemon(true);
t.start();
}
synchronized (decoderLock) {
decoderLock.notifyAll();
}
}
