Add GL demo app

Demonstrates rendering to a GLSurfaceView while applying a GL shader.

Issue: #6920
PiperOrigin-RevId: 293551724

RELEASENOTES.md

@@ -25,6 +25,7 @@
     ([#6753](https://github.com/google/ExoPlayer/issues/6753)).
   * Select multiple metadata tracks if multiple metadata renderers are available
     ([#6676](https://github.com/google/ExoPlayer/issues/6676)).
+  * Add support for ID3 genres added in Wimamp 5.6 (2010).
 * UI:
   * Show ad group markers in `DefaultTimeBar` even if they are after the end
     of the current window
@@ -54,7 +55,10 @@
   This issue caused FLAC streams with other bit depths to sound like white noise
   on earlier releases, but only when embedded in a non-FLAC container such as
   Matroska or MP4.
-* Add support for ID3 genres added in Wimamp 5.6 (2010).
+* Demo apps: Add
+  [GL demo app](https://github.com/google/ExoPlayer/tree/dev-v2/demos/gl) to
+  show how to render video to a `GLSurfaceView` while applying a GL shader.
+  ([#6920](https://github.com/google/ExoPlayer/issues/6920)).
 
 ### 2.11.1 (2019-12-20) ###
 

demos/gl/README.md

+# ExoPlayer GL demo
+
+This app demonstrates how to render video to a [GLSurfaceView][] while applying
+a GL shader.
+
+The shader shows an overlap bitmap on top of the video. The overlay bitmap is
+drawn using an Android canvas, and includes the current frame's presentation
+timestamp, to show how to get the timestamp of the frame currently in the
+off-screen surface texture.
+
+[GLSurfaceView]: https://developer.android.com/reference/android/opengl/GLSurfaceView

demos/gl/build.gradle

+// Copyright (C) 2020 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+apply from: '../../constants.gradle'
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion project.ext.compileSdkVersion
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+
+    defaultConfig {
+        versionName project.ext.releaseVersion
+        versionCode project.ext.releaseVersionCode
+        minSdkVersion project.ext.minSdkVersion
+        targetSdkVersion project.ext.appTargetSdkVersion
+    }
+
+    buildTypes {
+        release {
+            shrinkResources true
+            minifyEnabled true
+            proguardFiles getDefaultProguardFile('proguard-android.txt')
+        }
+    }
+
+    lintOptions {
+        // This demo app does not have translations.
+        disable 'MissingTranslation'
+    }
+}
+
+dependencies {
+    implementation project(modulePrefix + 'library-core')
+    implementation project(modulePrefix + 'library-ui')
+    implementation project(modulePrefix + 'library-dash')
+    implementation 'androidx.annotation:annotation:' + androidxAnnotationVersion
+    compileOnly 'org.checkerframework:checker-qual:' + checkerframeworkVersion
+    compileOnly 'org.checkerframework:checker-compat-qual:' + checkerframeworkVersion
+}

demos/gl/src/main/AndroidManifest.xml

+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2020 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.google.android.exoplayer2.gldemo">
+
+  <uses-permission android:name="android.permission.INTERNET"/>
+  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
+
+  <uses-sdk/>
+
+  <application
+      android:allowBackup="false"
+      android:icon="@mipmap/ic_launcher"
+      android:label="@string/application_name">
+
+    <activity
+        android:name=".MainActivity"
+        android:exported="true">
+      <intent-filter>
+        <action android:name="android.intent.action.MAIN"/>
+        <category android:name="android.intent.category.LAUNCHER"/>
+      </intent-filter>
+      <intent-filter>
+        <action android:name="com.google.android.exoplayer.gldemo.action.VIEW"/>
+        <category android:name="android.intent.category.DEFAULT"/>
+        <data android:scheme="http"/>
+        <data android:scheme="https"/>
+        <data android:scheme="content"/>
+        <data android:scheme="asset"/>
+        <data android:scheme="file"/>
+      </intent-filter>
+    </activity>
+
+  </application>
+
+</manifest>

demos/gl/src/main/assets/bitmap_overlay_video_processor_fragment.glsl

+// Copyright 2020 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#extension GL_OES_EGL_image_external : require
+precision mediump float;
+// External texture containing video decoder output.
+uniform samplerExternalOES tex_sampler_0;
+// Texture containing the overlap bitmap.
+uniform sampler2D tex_sampler_1;
+// Horizontal scaling factor for the overlap bitmap.
+uniform float scaleX;
+// Vertical scaling factory for the overlap bitmap.
+uniform float scaleY;
+varying vec2 v_texcoord;
+void main() {
+  vec4 videoColor = texture2D(tex_sampler_0, v_texcoord);
+  vec4 overlayColor = texture2D(tex_sampler_1,
+                                vec2(v_texcoord.x * scaleX,
+                                     v_texcoord.y * scaleY));
+  // Blend the video decoder output and the overlay bitmap.
+  gl_FragColor = videoColor * (1.0 - overlayColor.a)
+      + overlayColor * overlayColor.a;
+}
+

demos/gl/src/main/assets/bitmap_overlay_video_processor_vertex.glsl

+// Copyright 2020 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+attribute vec4 a_position;
+attribute vec3 a_texcoord;
+varying vec2 v_texcoord;
+void main() {
+ gl_Position = a_position;
+ v_texcoord = a_texcoord.xy;
+}
+

demos/gl/src/main/java/com/google/android/exoplayer2/gldemo/BitmapOverlayVideoProcessor.java

+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.android.exoplayer2.gldemo;
+
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.drawable.BitmapDrawable;
+import android.opengl.GLES20;
+import android.opengl.GLUtils;
+import androidx.annotation.Nullable;
+import com.google.android.exoplayer2.C;
+import com.google.android.exoplayer2.util.Assertions;
+import com.google.android.exoplayer2.util.GlUtil;
+import com.google.android.exoplayer2.util.Util;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Locale;
+import javax.microedition.khronos.opengles.GL10;
+
+/**
+ * Video processor that demonstrates how to overlay a bitmap on video output using a GL shader. The
+ * bitmap is drawn using an Android {@link Canvas}.
+ */
+/* package */ final class BitmapOverlayVideoProcessor
+    implements VideoProcessingGLSurfaceView.VideoProcessor {
+
+  private static final int OVERLAY_WIDTH = 512;
+  private static final int OVERLAY_HEIGHT = 256;
+
+  private final Context context;
+  private final Paint paint;
+  private final int[] textures;
+  private final Bitmap overlayBitmap;
+  private final Bitmap logoBitmap;
+  private final Canvas overlayCanvas;
+
+  private int program;
+  @Nullable private GlUtil.Attribute[] attributes;
+  @Nullable private GlUtil.Uniform[] uniforms;
+
+  private float bitmapScaleX;
+  private float bitmapScaleY;
+
+  public BitmapOverlayVideoProcessor(Context context) {
+    this.context = context.getApplicationContext();
+    paint = new Paint();
+    paint.setTextSize(64);
+    paint.setAntiAlias(true);
+    paint.setARGB(0xFF, 0xFF, 0xFF, 0xFF);
+    textures = new int[1];
+    overlayBitmap = Bitmap.createBitmap(OVERLAY_WIDTH, OVERLAY_HEIGHT, Bitmap.Config.ARGB_8888);
+    overlayCanvas = new Canvas(overlayBitmap);
+    try {
+      logoBitmap =
+          ((BitmapDrawable)
+                  context.getPackageManager().getApplicationIcon(context.getPackageName()))
+              .getBitmap();
+    } catch (PackageManager.NameNotFoundException e) {
+      throw new IllegalStateException(e);
+    }
+  }
+
+  @Override
+  public void initialize() {
+    String vertexShaderCode =
+        loadAssetAsString(context, "bitmap_overlay_video_processor_vertex.glsl");
+    String fragmentShaderCode =
+        loadAssetAsString(context, "bitmap_overlay_video_processor_fragment.glsl");
+    program = GlUtil.compileProgram(vertexShaderCode, fragmentShaderCode);
+    GlUtil.Attribute[] attributes = GlUtil.getAttributes(program);
+    GlUtil.Uniform[] uniforms = GlUtil.getUniforms(program);
+    for (GlUtil.Attribute attribute : attributes) {
+      if (attribute.name.equals("a_position")) {
+        attribute.setBuffer(
+            new float[] {
+              -1.0f, -1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f,
+              1.0f, 0.0f, 1.0f,
+            },
+            4);
+      } else if (attribute.name.equals("a_texcoord")) {
+        attribute.setBuffer(
+            new float[] {
+              0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f,
+            },
+            3);
+      }
+    }
+    this.attributes = attributes;
+    this.uniforms = uniforms;
+    GLES20.glGenTextures(1, textures, 0);
+    GLES20.glBindTexture(GL10.GL_TEXTURE_2D, textures[0]);
+    GLES20.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_NEAREST);
+    GLES20.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);
+    GLES20.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_S, GL10.GL_REPEAT);
+    GLES20.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_T, GL10.GL_REPEAT);
+    GLUtils.texImage2D(GL10.GL_TEXTURE_2D, /* level= */ 0, overlayBitmap, /* border= */ 0);
+  }
+
+  @Override
+  public void setSurfaceSize(int width, int height) {
+    bitmapScaleX = (float) width / OVERLAY_WIDTH;
+    bitmapScaleY = (float) height / OVERLAY_HEIGHT;
+  }
+
+  @Override
+  public void draw(int frameTexture, long frameTimestampUs) {
+    // Draw to the canvas and store it in a texture.
+    String text = String.format(Locale.US, "%.02f", frameTimestampUs / (float) C.MICROS_PER_SECOND);
+    overlayBitmap.eraseColor(Color.TRANSPARENT);
+    overlayCanvas.drawBitmap(logoBitmap, /* left= */ 32, /* top= */ 32, paint);
+    overlayCanvas.drawText(text, /* x= */ 200, /* y= */ 130, paint);
+    GLES20.glBindTexture(GL10.GL_TEXTURE_2D, textures[0]);
+    GLUtils.texSubImage2D(
+        GL10.GL_TEXTURE_2D, /* level= */ 0, /* xoffset= */ 0, /* yoffset= */ 0, overlayBitmap);
+    GlUtil.checkGlError();
+
+    // Run the shader program.
+    GlUtil.Uniform[] uniforms = Assertions.checkNotNull(this.uniforms);
+    GlUtil.Attribute[] attributes = Assertions.checkNotNull(this.attributes);
+    GLES20.glUseProgram(program);
+    for (GlUtil.Uniform uniform : uniforms) {
+      switch (uniform.name) {
+        case "tex_sampler_0":
+          uniform.setSamplerTexId(frameTexture, /* unit= */ 0);
+          break;
+        case "tex_sampler_1":
+          uniform.setSamplerTexId(textures[0], /* unit= */ 1);
+          break;
+        case "scaleX":
+          uniform.setFloat(bitmapScaleX);
+          break;
+        case "scaleY":
+          uniform.setFloat(bitmapScaleY);
+          break;
+      }
+    }
+    for (GlUtil.Attribute copyExternalAttribute : attributes) {
+      copyExternalAttribute.bind();
+    }
+    for (GlUtil.Uniform copyExternalUniform : uniforms) {
+      copyExternalUniform.bind();
+    }
+    GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
+    GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, /* first= */ 0, /* count= */ 4);
+    GlUtil.checkGlError();
+  }
+
+  private static String loadAssetAsString(Context context, String assetFileName) {
+    @Nullable InputStream inputStream = null;
+    try {
+      inputStream = context.getAssets().open(assetFileName);
+      return Util.fromUtf8Bytes(Util.toByteArray(inputStream));
+    } catch (IOException e) {
+      throw new IllegalStateException(e);
+    } finally {
+      Util.closeQuietly(inputStream);
+    }
+  }
+}

demos/gl/src/main/java/com/google/android/exoplayer2/gldemo/MainActivity.java

+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.android.exoplayer2.gldemo;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Bundle;
+import android.widget.FrameLayout;
+import android.widget.Toast;
+import androidx.annotation.Nullable;
+import com.google.android.exoplayer2.C;
+import com.google.android.exoplayer2.Player;
+import com.google.android.exoplayer2.SimpleExoPlayer;
+import com.google.android.exoplayer2.drm.DefaultDrmSessionManager;
+import com.google.android.exoplayer2.drm.DrmSessionManager;
+import com.google.android.exoplayer2.drm.ExoMediaCrypto;
+import com.google.android.exoplayer2.drm.FrameworkMediaDrm;
+import com.google.android.exoplayer2.drm.HttpMediaDrmCallback;
+import com.google.android.exoplayer2.source.MediaSource;
+import com.google.android.exoplayer2.source.ProgressiveMediaSource;
+import com.google.android.exoplayer2.source.dash.DashMediaSource;
+import com.google.android.exoplayer2.ui.PlayerView;
+import com.google.android.exoplayer2.upstream.DataSource;
+import com.google.android.exoplayer2.upstream.DefaultDataSourceFactory;
+import com.google.android.exoplayer2.upstream.DefaultHttpDataSourceFactory;
+import com.google.android.exoplayer2.upstream.HttpDataSource;
+import com.google.android.exoplayer2.util.Assertions;
+import com.google.android.exoplayer2.util.EventLogger;
+import com.google.android.exoplayer2.util.GlUtil;
+import com.google.android.exoplayer2.util.Util;
+import java.util.UUID;
+
+/**
+ * Activity that demonstrates playback of video to an {@link android.opengl.GLSurfaceView} with
+ * postprocessing of the video content using GL.
+ */
+public final class MainActivity extends Activity {
+
+  private static final String DEFAULT_MEDIA_URI =
+      "https://storage.googleapis.com/exoplayer-test-media-1/mkv/android-screens-lavf-56.36.100-aac-avc-main-1280x720.mkv";
+
+  private static final String ACTION_VIEW = "com.google.android.exoplayer.gldemo.action.VIEW";
+  private static final String EXTENSION_EXTRA = "extension";
+  private static final String DRM_SCHEME_EXTRA = "drm_scheme";
+  private static final String DRM_LICENSE_URL_EXTRA = "drm_license_url";
+
+  @Nullable private PlayerView playerView;
+  @Nullable private VideoProcessingGLSurfaceView videoProcessingGLSurfaceView;
+
+  @Nullable private SimpleExoPlayer player;
+
+  @Override
+  protected void onCreate(@Nullable Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    setContentView(R.layout.main_activity);
+    playerView = findViewById(R.id.player_view);
+
+    Context context = getApplicationContext();
+    boolean requestSecureSurface = getIntent().hasExtra(DRM_SCHEME_EXTRA);
+    if (requestSecureSurface && !GlUtil.isProtectedContentExtensionSupported(context)) {
+      Toast.makeText(
+              context, R.string.error_protected_content_extension_not_supported, Toast.LENGTH_LONG)
+          .show();
+    }
+
+    VideoProcessingGLSurfaceView videoProcessingGLSurfaceView =
+        new VideoProcessingGLSurfaceView(
+            context, requestSecureSurface, new BitmapOverlayVideoProcessor(context));
+    FrameLayout contentFrame = findViewById(R.id.exo_content_frame);
+    contentFrame.addView(videoProcessingGLSurfaceView);
+    this.videoProcessingGLSurfaceView = videoProcessingGLSurfaceView;
+  }
+
+  @Override
+  public void onStart() {
+    super.onStart();
+    if (Util.SDK_INT > 23) {
+      initializePlayer();
+      if (playerView != null) {
+        playerView.onResume();
+      }
+    }
+  }
+
+  @Override
+  public void onResume() {
+    super.onResume();
+    if (Util.SDK_INT <= 23 || player == null) {
+      initializePlayer();
+      if (playerView != null) {
+        playerView.onResume();
+      }
+    }
+  }
+
+  @Override
+  public void onPause() {
+    super.onPause();
+    if (Util.SDK_INT <= 23) {
+      if (playerView != null) {
+        playerView.onPause();
+      }
+      releasePlayer();
+    }
+  }
+
+  @Override
+  public void onStop() {
+    super.onStop();
+    if (Util.SDK_INT > 23) {
+      if (playerView != null) {
+        playerView.onPause();
+      }
+      releasePlayer();
+    }
+  }
+
+  private void initializePlayer() {
+    Intent intent = getIntent();
+    String action = intent.getAction();
+    Uri uri =
+        ACTION_VIEW.equals(action)
+            ? Assertions.checkNotNull(intent.getData())
+            : Uri.parse(DEFAULT_MEDIA_URI);
+    String userAgent = Util.getUserAgent(this, getString(R.string.application_name));
+    DrmSessionManager<ExoMediaCrypto> drmSessionManager;
+    if (Util.SDK_INT >= 18 && intent.hasExtra(DRM_SCHEME_EXTRA)) {
+      String drmScheme = Assertions.checkNotNull(intent.getStringExtra(DRM_SCHEME_EXTRA));
+      String drmLicenseUrl = Assertions.checkNotNull(intent.getStringExtra(DRM_LICENSE_URL_EXTRA));
+      UUID drmSchemeUuid = Assertions.checkNotNull(Util.getDrmUuid(drmScheme));
+      HttpDataSource.Factory licenseDataSourceFactory = new DefaultHttpDataSourceFactory(userAgent);
+      HttpMediaDrmCallback drmCallback =
+          new HttpMediaDrmCallback(drmLicenseUrl, licenseDataSourceFactory);
+      drmSessionManager =
+          new DefaultDrmSessionManager.Builder()
+              .setUuidAndExoMediaDrmProvider(drmSchemeUuid, FrameworkMediaDrm.DEFAULT_PROVIDER)
+              .build(drmCallback);
+    } else {
+      drmSessionManager = DrmSessionManager.getDummyDrmSessionManager();
+    }
+
+    DataSource.Factory dataSourceFactory =
+        new DefaultDataSourceFactory(
+            this, Util.getUserAgent(this, getString(R.string.application_name)));
+    MediaSource mediaSource;
+    @C.ContentType int type = Util.inferContentType(uri, intent.getStringExtra(EXTENSION_EXTRA));
+    if (type == C.TYPE_DASH) {
+      mediaSource =
+          new DashMediaSource.Factory(dataSourceFactory)
+              .setDrmSessionManager(drmSessionManager)
+              .createMediaSource(uri);
+    } else if (type == C.TYPE_OTHER) {
+      mediaSource =
+          new ProgressiveMediaSource.Factory(dataSourceFactory)
+              .setDrmSessionManager(drmSessionManager)
+              .createMediaSource(uri);
+    } else {
+      throw new IllegalStateException();
+    }
+
+    SimpleExoPlayer player = new SimpleExoPlayer.Builder(getApplicationContext()).build();
+    player.setRepeatMode(Player.REPEAT_MODE_ALL);
+    player.prepare(mediaSource);
+    player.setPlayWhenReady(true);
+    VideoProcessingGLSurfaceView videoProcessingGLSurfaceView =
+        Assertions.checkNotNull(this.videoProcessingGLSurfaceView);
+    videoProcessingGLSurfaceView.setVideoComponent(
+        Assertions.checkNotNull(player.getVideoComponent()));
+    Assertions.checkNotNull(playerView).setPlayer(player);
+    player.addAnalyticsListener(new EventLogger(/* trackSelector= */ null));
+    this.player = player;
+  }
+
+  private void releasePlayer() {
+    Assertions.checkNotNull(playerView).setPlayer(null);
+    if (player != null) {
+      player.release();
+      Assertions.checkNotNull(videoProcessingGLSurfaceView).setVideoComponent(null);
+      player = null;
+    }
+  }
+}

demos/gl/src/main/res/layout/main_activity.xml

+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2020 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<FrameLayout
+  xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:app="http://schemas.android.com/apk/res-auto"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  android:keepScreenOn="true">
+
+  <com.google.android.exoplayer2.ui.PlayerView
+    android:id="@+id/player_view"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    app:surface_type="none"/>
+
+</FrameLayout>
+

demos/gl/src/main/res/values/strings.xml

+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2020 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<resources>
+
+  <string name="application_name">ExoPlayer GL demo</string>
+
+  <string name="error_protected_content_extension_not_supported">The GL protected content extension is not supported.</string>
+
+</resources>

library/core/src/main/java/com/google/android/exoplayer2/video/DummySurface.java

@@ -21,10 +21,7 @@ import static com.google.android.exoplayer2.util.EGLSurfaceTexture.SECURE_MODE_S
 
 import android.annotation.TargetApi;
 import android.content.Context;
-import android.content.pm.PackageManager;
 import android.graphics.SurfaceTexture;
-import android.opengl.EGL14;
-import android.opengl.EGLDisplay;
 import android.os.Handler;
 import android.os.Handler.Callback;
 import android.os.HandlerThread;
@@ -34,22 +31,17 @@ import androidx.annotation.Nullable;
 import com.google.android.exoplayer2.util.Assertions;
 import com.google.android.exoplayer2.util.EGLSurfaceTexture;
 import com.google.android.exoplayer2.util.EGLSurfaceTexture.SecureMode;
+import com.google.android.exoplayer2.util.GlUtil;
 import com.google.android.exoplayer2.util.Log;
 import com.google.android.exoplayer2.util.Util;
-import javax.microedition.khronos.egl.EGL10;
 import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
 
-/**
- * A dummy {@link Surface}.
- */
+/** A dummy {@link Surface}. */
 @TargetApi(17)
 public final class DummySurface extends Surface {
 
   private static final String TAG = "DummySurface";
 
-  private static final String EXTENSION_PROTECTED_CONTENT = "EGL_EXT_protected_content";
-  private static final String EXTENSION_SURFACELESS_CONTEXT = "EGL_KHR_surfaceless_context";
-
   /**
    * Whether the surface is secure.
    */
@@ -69,7 +61,7 @@ public final class DummySurface extends Surface {
    */
   public static synchronized boolean isSecureSupported(Context context) {
     if (!secureModeInitialized) {
-      secureMode = Util.SDK_INT < 24 ? SECURE_MODE_NONE : getSecureModeV24(context);
+      secureMode = getSecureMode(context);
       secureModeInitialized = true;
     }
     return secureMode != SECURE_MODE_NONE;
@@ -121,34 +113,21 @@ public final class DummySurface extends Surface {
     }
   }
 
-  @TargetApi(24)
-  private static @SecureMode int getSecureModeV24(Context context) {
-    if (Util.SDK_INT < 26 && ("samsung".equals(Util.MANUFACTURER) || "XT1650".equals(Util.MODEL))) {
-      // Samsung devices running Nougat are known to be broken. See
-      // https://github.com/google/ExoPlayer/issues/3373 and [Internal: b/37197802].
-      // Moto Z XT1650 is also affected. See
-      // https://github.com/google/ExoPlayer/issues/3215.
-      return SECURE_MODE_NONE;
-    }
-    if (Util.SDK_INT < 26 && !context.getPackageManager().hasSystemFeature(
-        PackageManager.FEATURE_VR_MODE_HIGH_PERFORMANCE)) {
-      // Pre API level 26 devices were not well tested unless they supported VR mode.
-      return SECURE_MODE_NONE;
-    }
-    EGLDisplay display = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
-    String eglExtensions = EGL14.eglQueryString(display, EGL10.EGL_EXTENSIONS);
-    if (eglExtensions == null) {
-      return SECURE_MODE_NONE;
+  @SecureMode
+  private static int getSecureMode(Context context) {
+    if (GlUtil.isProtectedContentExtensionSupported(context)) {
+      if (GlUtil.isSurfacelessContextExtensionSupported()) {
+        return SECURE_MODE_SURFACELESS_CONTEXT;
+      } else {
+        // If we can't use surfaceless contexts, we use a protected 1 * 1 pixel buffer surface.
+        // This may require support for EXT_protected_surface, but in practice it works on some
+        // devices that don't have that extension. See also
+        // https://github.com/google/ExoPlayer/issues/3558.
+        return SECURE_MODE_PROTECTED_PBUFFER;
       }
-    if (!eglExtensions.contains(EXTENSION_PROTECTED_CONTENT)) {
+    } else {
       return SECURE_MODE_NONE;
     }
-    // If we can't use surfaceless contexts, we use a protected 1 * 1 pixel buffer surface. This may
-    // require support for EXT_protected_surface, but in practice it works on some devices that
-    // don't have that extension. See also https://github.com/google/ExoPlayer/issues/3558.
-    return eglExtensions.contains(EXTENSION_SURFACELESS_CONTEXT)
-        ? SECURE_MODE_SURFACELESS_CONTEXT
-        : SECURE_MODE_PROTECTED_PBUFFER;
   }
 
   private static class DummySurfaceThread extends HandlerThread implements Callback {

settings.gradle

@@ -20,10 +20,12 @@ if (gradle.ext.has('exoplayerModulePrefix')) {
 
 include modulePrefix + 'demo'
 include modulePrefix + 'demo-cast'
+include modulePrefix + 'demo-gl'
 include modulePrefix + 'demo-surface'
 include modulePrefix + 'playbacktests'
 project(modulePrefix + 'demo').projectDir = new File(rootDir, 'demos/main')
 project(modulePrefix + 'demo-cast').projectDir = new File(rootDir, 'demos/cast')
+project(modulePrefix + 'demo-gl').projectDir = new File(rootDir, 'demos/gl')
 project(modulePrefix + 'demo-surface').projectDir = new File(rootDir, 'demos/surface')
 project(modulePrefix + 'playbacktests').projectDir = new File(rootDir, 'playbacktests')