loliball/media3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Further improve codec reconfiguration

Browse Source 
- Only setup a codec to allow adaptation to other compatible
  formats in the stream. If something like the mimeType is
  changing adaptation will never be possible, so there's no
  point.
- Incorporate maxInputSize into the reconfiguration logic.

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=129088464
This commit is contained in:
olly 2016-08-02 05:30:12 -07:00 committed by Oliver Woodman
parent bd7c8fed1b
commit 490c5fea78
1 changed files with 95 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

142
library/src/main/java/com/google/android/exoplayer2/video/MediaCodecVideoRenderer.java
View File

@ -23,7 +23,6 @@ import android.media.MediaCrypto;
import android.media.MediaFormat;
import android.os.Handler;
import android.os.SystemClock;
import android.util.Log;
import android.view.Surface;
import com.google.android.exoplayer2.C;
import com.google.android.exoplayer2.ExoPlaybackException;
@ -60,10 +59,8 @@ public class MediaCodecVideoRenderer extends MediaCodecRenderer {
private final int maxDroppedFramesToNotify;
private final boolean deviceNeedsAutoFrcWorkaround;
private int maxWidth;
private int maxHeight;
private int configuredMaxWidth;
private int configuredMaxHeight;
private Format[] streamFormats;
private CodecMaxValues codecMaxValues;
private Surface surface;
private boolean reportedDrawnToSurface;
@ -221,18 +218,7 @@ public class MediaCodecVideoRenderer extends MediaCodecRenderer {
@Override
protected void onStreamChanged(Format[] formats) throws ExoPlaybackException {
maxWidth = Format.NO_VALUE;
maxHeight = Format.NO_VALUE;
for (Format format : formats) {
maxWidth = Math.max(maxWidth, format.width);
maxHeight = Math.max(maxHeight, format.height);
}
if (formats.length > 1 && (maxWidth == Format.NO_VALUE || maxHeight == Format.NO_VALUE)) {
// TODO: Consider replacing this block with one that sets values injected via the constructor.
Log.w(TAG, "Maximum dimensions unknown for adaptive playback. Assuming 1920x1080.");
maxWidth = 1920;
maxHeight = 1080;
}
streamFormats = formats;
super.onStreamChanged(formats);
}
@ -323,15 +309,11 @@ public class MediaCodecVideoRenderer extends MediaCodecRenderer {
return super.shouldInitCodec() && surface != null && surface.isValid();
}
// Override configureCodec to provide the surface.
@Override
protected void configureCodec(MediaCodec codec, Format format, MediaCrypto crypto) {
maxWidth = Math.max(maxWidth, format.width);
maxHeight = Math.max(maxHeight, format.height);
codec.configure(getFrameworkFormat(format, maxWidth, maxHeight, deviceNeedsAutoFrcWorkaround),
surface, crypto, 0);
configuredMaxWidth = maxWidth;
configuredMaxHeight = maxHeight;
codecMaxValues = getCodecMaxValues(format, streamFormats);
MediaFormat mediaFormat = getMediaFormat(format, codecMaxValues, deviceNeedsAutoFrcWorkaround);
codec.configure(mediaFormat, surface, crypto, 0);
}
@Override
@ -381,9 +363,9 @@ public class MediaCodecVideoRenderer extends MediaCodecRenderer {
@Override
protected boolean canReconfigureCodec(MediaCodec codec, boolean codecIsAdaptive,
Format oldFormat, Format newFormat) {
return newFormat.sampleMimeType.equals(oldFormat.sampleMimeType)
&& getRotationDegrees(newFormat) == getRotationDegrees(oldFormat)
&& newFormat.width <= configuredMaxWidth && newFormat.height <= configuredMaxHeight
return areAdaptationCompatible(oldFormat, newFormat)
&& newFormat.width <= codecMaxValues.width && newFormat.height <= codecMaxValues.height
&& newFormat.maxInputSize <= codecMaxValues.inputSize
&& (codecIsAdaptive
|| (oldFormat.width == newFormat.width && oldFormat.height == newFormat.height));
}
@ -502,60 +484,98 @@ public class MediaCodecVideoRenderer extends MediaCodecRenderer {
}
@SuppressLint("InlinedApi")
private static android.media.MediaFormat getFrameworkFormat(Format format, int maxWidth,
int maxHeight, boolean deviceNeedsAutoFrcWorkaround) {
android.media.MediaFormat frameworkMediaFormat = format.getFrameworkMediaFormatV16();
private static MediaFormat getMediaFormat(Format format, CodecMaxValues codecMaxValues,
boolean deviceNeedsAutoFrcWorkaround) {
MediaFormat frameworkMediaFormat = format.getFrameworkMediaFormatV16();
// Set the maximum adaptive video dimensions.
frameworkMediaFormat.setInteger(MediaFormat.KEY_MAX_WIDTH, codecMaxValues.width);
frameworkMediaFormat.setInteger(MediaFormat.KEY_MAX_HEIGHT, codecMaxValues.height);
// Set the maximum input size.
if (codecMaxValues.inputSize != Format.NO_VALUE) {
frameworkMediaFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, codecMaxValues.inputSize);
}
// Set FRC workaround.
if (deviceNeedsAutoFrcWorkaround) {
frameworkMediaFormat.setInteger("auto-frc", 0);
}
return frameworkMediaFormat;
}
// Set the maximum adaptive video dimensions.
frameworkMediaFormat.setInteger(MediaFormat.KEY_MAX_WIDTH, maxWidth);
frameworkMediaFormat.setInteger(MediaFormat.KEY_MAX_HEIGHT, maxHeight);
/**
* Returns {@link CodecMaxValues} suitable for configuring a codec for {@code format} in a way
* that will allow possible adaptation to other compatible formats in {@code streamFormats}.
*
* @param format The format for which the codec is being configured.
* @param streamFormats The possible stream formats.
* @return Suitable {@link CodecMaxValues}.
*/
private static CodecMaxValues getCodecMaxValues(Format format, Format[] streamFormats) {
int maxWidth = format.width;
int maxHeight = format.height;
int maxInputSize = getMaxInputSize(format);
for (Format streamFormat : streamFormats) {
if (areAdaptationCompatible(format, streamFormat)) {
maxWidth = Math.max(maxWidth, streamFormat.width);
maxHeight = Math.max(maxHeight, streamFormat.height);
maxInputSize = Math.max(maxInputSize, getMaxInputSize(streamFormat));
}
}
return new CodecMaxValues(maxWidth, maxHeight, maxInputSize);
}
if (format.maxInputSize > 0) {
// The format already has a maximum input size.
return frameworkMediaFormat;
/**
* Returns a maximum input size for a given format.
*
* @param format The format.
* @return An maximum input size in bytes, or {@link Format#NO_VALUE} if a maximum could not be
* determined.
*/
private static int getMaxInputSize(Format format) {
if (format.maxInputSize != Format.NO_VALUE) {
// The format defines an explicit maximum input size.
return format.maxInputSize;
}
// If the format doesn't define a maximum input size, determine one ourselves.
if (format.width == Format.NO_VALUE || format.height == Format.NO_VALUE) {
// We can't infer a maximum input size without video dimensions.
return Format.NO_VALUE;
}
// Attempt to infer a maximum input size from the format.
int maxPixels;
int minCompressionRatio;
switch (format.sampleMimeType) {
case MimeTypes.VIDEO_H263:
case MimeTypes.VIDEO_MP4V:
maxPixels = maxWidth * maxHeight;
maxPixels = format.width * format.height;
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 frameworkMediaFormat;
return Format.NO_VALUE;
}
// Round up width/height to an integer number of macroblocks.
maxPixels = ((maxWidth + 15) / 16) * ((maxHeight + 15) / 16) * 16 * 16;
maxPixels = ((format.width + 15) / 16) * ((format.height + 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;
maxPixels = format.width * format.height;
minCompressionRatio = 2;
break;
case MimeTypes.VIDEO_H265:
case MimeTypes.VIDEO_VP9:
maxPixels = maxWidth * maxHeight;
maxPixels = format.width * format.height;
minCompressionRatio = 4;
break;
default:
// Leave the default max input size.
return frameworkMediaFormat;
return Format.NO_VALUE;
}
// Estimate the maximum input size assuming three channel 4:2:0 subsampled input frames.
int maxInputSize = (maxPixels * 3) / (2 * minCompressionRatio);
frameworkMediaFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, maxInputSize);
return frameworkMediaFormat;
return (maxPixels * 3) / (2 * minCompressionRatio);
}
private void maybeNotifyDrawnToSurface() {
@ -606,6 +626,20 @@ public class MediaCodecVideoRenderer extends MediaCodecRenderer {
return Util.SDK_INT <= 22 && "foster".equals(Util.DEVICE) && "NVIDIA".equals(Util.MANUFACTURER);
}
/**
* Returns whether an adaptive codec with suitable {@link CodecMaxValues} will support adaptation
* between two {@link Format}s.
*
* @param first The first format.
* @param second The second format.
* @return Whether an adaptive codec with suitable {@link CodecMaxValues} will support adaptation
* between two {@link Format}s.
*/
private static boolean areAdaptationCompatible(Format first, Format second) {
return first.sampleMimeType.equals(second.sampleMimeType)
&& getRotationDegrees(first) == getRotationDegrees(second);
}
private static float getPixelWidthHeightRatio(Format format) {
return format.pixelWidthHeightRatio == Format.NO_VALUE ? 1 : format.pixelWidthHeightRatio;
}
@ -614,4 +648,18 @@ public class MediaCodecVideoRenderer extends MediaCodecRenderer {
return format.rotationDegrees == Format.NO_VALUE ? 0 : format.rotationDegrees;
}
private static final class CodecMaxValues {
public final int width;
public final int height;
public final int inputSize;
public CodecMaxValues(int width, int height, int inputSize) {
this.width = width;
this.height = height;
this.inputSize = inputSize;
}
}
}