Add texture support to HardwareVideoEncoder.

webrtc/sdk/android/api/org/webrtc/HardwareVideoEncoderFactory.java

 /*
  *  Copyright 2017 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 37 matching lines @@
 
   // Supported H264 profile ids and levels.
   private static final String H264_PROFILE_CONSTRAINED_BASELINE = "4200";
   private static final String H264_PROFILE_CONSTRAINED_HIGH = "640c";
   private static final String H264_LEVEL_3_1 = "1f"; // 31 in hex.
   private static final String H264_CONSTRAINED_BASELINE_3_1 =
       H264_PROFILE_CONSTRAINED_BASELINE + H264_LEVEL_3_1;
   private static final String H264_CONSTRAINED_HIGH_3_1 =
       H264_PROFILE_CONSTRAINED_HIGH + H264_LEVEL_3_1;
 
+  private final EglBase14.Context sharedContext;
   private final boolean enableIntelVp8Encoder;
   private final boolean enableH264HighProfile;
 
-  public HardwareVideoEncoderFactory(boolean enableIntelVp8Encoder, boolean enableH264HighProfile) {
+  public HardwareVideoEncoderFactory(
+      EglBase.Context sharedContext, boolean enableIntelVp8Encoder, boolean enableH264HighProfile) {
+    // Texture mode requires EglBase14.
+    if (sharedContext instanceof EglBase14.Context) {

[sakal, 2017/07/17 12:25:41]

I would prefer this just taking in EglBase14.Context.

[mellem, 2017/07/17 17:49:29]

EglBase14 is not part of the api (it's a package-private class in the
src/java/... directory) and callers outside webrtc can't instantiate it.  I need
to take an argument that callers can actually create, or I can't reuse hardware
encoding in texture mode outside webrtc.

+      this.sharedContext = (EglBase14.Context) sharedContext;
+    } else {
+      this.sharedContext = null;
+    }
     this.enableIntelVp8Encoder = enableIntelVp8Encoder;
     this.enableH264HighProfile = enableH264HighProfile;
   }
 
+  @Deprecated
+  public HardwareVideoEncoderFactory(boolean enableIntelVp8Encoder, boolean enableH264HighProfile) {
+    this(null, enableIntelVp8Encoder, enableH264HighProfile);
+  }
+
   @Override
   public VideoEncoder createEncoder(VideoCodecInfo input) {
     VideoCodecType type = VideoCodecType.valueOf(input.name);
     MediaCodecInfo info = findCodecForType(type);
 
     if (info == null) {
       return null; // No support for this type.
     }
 
     String codecName = info.getName();
     String mime = type.mimeType();
-    int colorFormat = MediaCodecUtils.selectColorFormat(
-        MediaCodecUtils.ENCODER_COLOR_FORMATS, info.getCapabilitiesForType(mime));
+    int colorFormat = MediaCodecUtils.selectColorFormat(sharedContext == null
+            ? MediaCodecUtils.ENCODER_COLOR_FORMATS
+            : MediaCodecUtils.TEXTURE_COLOR_FORMATS,
+        info.getCapabilitiesForType(mime));
 
     return new HardwareVideoEncoder(codecName, type, colorFormat, getKeyFrameIntervalSec(type),
-        getForcedKeyFrameIntervalMs(type, codecName), createBitrateAdjuster(type, codecName));
+        getForcedKeyFrameIntervalMs(type, codecName), createBitrateAdjuster(type, codecName),
+        sharedContext);
   }
 
   @Override
   public VideoCodecInfo[] getSupportedCodecs() {
     List<VideoCodecInfo> supportedCodecInfos = new ArrayList<VideoCodecInfo>();
     // Generate a list of supported codecs in order of preference:
     // VP8, VP9, H264 (high profile), and H264 (baseline profile).
     for (VideoCodecType type :
         new VideoCodecType[] {VideoCodecType.VP8, VideoCodecType.VP9, VideoCodecType.H264}) {
       MediaCodecInfo codec = findCodecForType(type);
@@ skipping 28 matching lines @@
     }
     return null; // No support for this type.
   }
 
   // Returns true if the given MediaCodecInfo indicates a supported encoder for the given type.
   private boolean isSupportedCodec(MediaCodecInfo info, VideoCodecType type) {
     if (!MediaCodecUtils.codecSupportsType(info, type)) {
       return false;
     }
     // Check for a supported color format.
-    if (MediaCodecUtils.selectColorFormat(
-            MediaCodecUtils.ENCODER_COLOR_FORMATS, info.getCapabilitiesForType(type.mimeType()))
+    if (MediaCodecUtils.selectColorFormat(sharedContext == null
+                ? MediaCodecUtils.ENCODER_COLOR_FORMATS
+                : MediaCodecUtils.TEXTURE_COLOR_FORMATS,
+            info.getCapabilitiesForType(type.mimeType()))
         == null) {
       return false;
     }
     return isHardwareSupportedInCurrentSdk(info, type);
   }
 
   // Returns true if the given MediaCodecInfo indicates a hardware module that is supported on the
   // current SDK.
   private boolean isHardwareSupportedInCurrentSdk(MediaCodecInfo info, VideoCodecType type) {
     switch (type) {
@@ skipping 92 matching lines @@
         properties.put(H264_FMTP_LEVEL_ASYMMETRY_ALLOWED, "1");
         properties.put(H264_FMTP_PACKETIZATION_MODE, "1");
         properties.put(H264_FMTP_PROFILE_LEVEL_ID,
             highProfile ? H264_CONSTRAINED_HIGH_3_1 : H264_CONSTRAINED_BASELINE_3_1);
         return properties;
       default:
         throw new IllegalArgumentException("Unsupported codec: " + type);
     }
   }
 }