Use MediaCodec.setOutputSurface() for fullscreen transitions on M.

media/filters/gpu_video_decoder.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/filters/gpu_video_decoder.h"
 
 #include <algorithm>
 #include <array>
 #include <utility>
 
@@ skipping 18 matching lines @@
 #include "media/base/pipeline_status.h"
 #include "media/base/surface_manager.h"
 #include "media/base/video_decoder_config.h"
 #include "media/renderers/gpu_video_accelerator_factories.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 #if defined(USE_PROPRIETARY_CODECS)
 #include "media/formats/mp4/box_definitions.h"
 #endif
 
+#if defined(OS_ANDROID)
+#include "base/android/build_info.h"
+#endif
+
 namespace media {
 namespace {
 
 // Size of shared-memory segments we allocate.  Since we reuse them we let them
 // be on the beefy side.
 static const size_t kSharedMemorySegmentBytes = 100 << 10;
 
 #if defined(OS_ANDROID) && defined(USE_PROPRIETARY_CODECS)
 // Extract the SPS and PPS lists from |extra_data|. Each SPS and PPS is prefixed
 // with 0x0001, the Annex B framing bytes. The out parameters are not modified
@@ skipping 156 matching lines @@
                                  const InitCB& init_cb,
                                  const OutputCB& output_cb) {
   DVLOG(3) << "Initialize()";
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   DCHECK(config.IsValidConfig());
 
   InitCB bound_init_cb =
       base::Bind(&ReportGpuVideoDecoderInitializeStatusToUMAAndRunCB,
                  BindToCurrentLoop(init_cb), media_log_);
 
+  bool requires_restart_for_external_output_surface = false;
 #if !defined(OS_ANDROID)
   if (config.is_encrypted()) {
     DVLOG(1) << "Encrypted stream not supported.";
     bound_init_cb.Run(false);
     return;
   }
+#else
+  requires_restart_for_external_output_surface =
+      base::android::BuildInfo::GetInstance()->sdk_int() < 23;
 #endif
 
   bool previously_initialized = config_.IsValidConfig();
   DVLOG(1) << (previously_initialized ? "Reinitializing" : "Initializing")
            << " GVD with config: " << config.AsHumanReadableString();
 
   // Disallow codec changes between configuration changes.
   if (previously_initialized && config_.codec() != config.codec()) {
     DVLOG(1) << "Codec changed, cannot reinitialize.";
     bound_init_cb.Run(false);
@@ skipping 71 matching lines @@
 
   init_cb_ = bound_init_cb;
 
   const bool supports_external_output_surface =
       (capabilities.flags & VideoDecodeAccelerator::Capabilities::
                                 SUPPORTS_EXTERNAL_OUTPUT_SURFACE) != 0;
   if (supports_external_output_surface && !request_surface_cb_.is_null()) {
     // If we have a surface request callback we should call it and complete
     // initialization with the returned surface.
     request_surface_cb_.Run(
+        requires_restart_for_external_output_surface,
         BindToCurrentLoop(base::Bind(&GpuVideoDecoder::CompleteInitialization,
                                      weak_factory_.GetWeakPtr(), cdm_id)));
     return;
   }
 
   // If we don't have to wait for a surface complete initialization with a null
   // surface.
   CompleteInitialization(cdm_id, SurfaceManager::kNoSurfaceID);
 }
 
 void GpuVideoDecoder::CompleteInitialization(int cdm_id, int surface_id) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
-  DCHECK(!init_cb_.is_null());
 
   // It's possible for the vda to become null if NotifyError is called.
   if (!vda_) {
     base::ResetAndReturn(&init_cb_).Run(false);
     return;
   }
 
+  vda_->SetSurface(surface_id);
+
+  // If initialization has already completed, there's nothing left to do.
+  if (init_cb_.is_null())
+    return;

[watk, 2016/11/03 20:26:34]

Not sure how this is hit?

[DaleCurtis, 2016/11/04 01:07:22]

Heh, without this we can't change surfaces :) -- that always happens post-init.

+
   VideoDecodeAccelerator::Config vda_config;
   vda_config.profile = config_.profile();
   vda_config.cdm_id = cdm_id;
   vda_config.is_encrypted = config_.is_encrypted();
-  vda_config.surface_id = surface_id;
   vda_config.is_deferred_initialization_allowed = true;
   vda_config.initial_expected_coded_size = config_.coded_size();
 
 #if defined(OS_ANDROID) && defined(USE_PROPRIETARY_CODECS)
   // We pass the SPS and PPS on Android because it lets us initialize
   // MediaCodec more reliably (http://crbug.com/649185).
   if (config_.codec() == kCodecH264)
     ExtractSpsAndPps(config_.extra_data(), &vda_config.sps, &vda_config.pps);
 #endif
 
@@ skipping 431 matching lines @@
   DVLOG(3) << __func__;
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
   if (vda_)
     DestroyVDA();
   DCHECK(assigned_picture_buffers_.empty());
 
   if (!init_cb_.is_null())
     base::ResetAndReturn(&init_cb_).Run(false);
   if (!request_surface_cb_.is_null())
-    base::ResetAndReturn(&request_surface_cb_).Run(SurfaceCreatedCB());
+    base::ResetAndReturn(&request_surface_cb_).Run(false, SurfaceCreatedCB());
 
   for (size_t i = 0; i < available_shm_segments_.size(); ++i) {
     delete available_shm_segments_[i];
   }
   available_shm_segments_.clear();
 
   for (std::map<int32_t, PendingDecoderBuffer>::iterator it =
            bitstream_buffers_in_decoder_.begin();
        it != bitstream_buffers_in_decoder_.end(); ++it) {
     delete it->second.shm_buffer;
@@ skipping 71 matching lines @@
   }
   return false;
 }
 
 void GpuVideoDecoder::DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent()
     const {
   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
 }  // namespace media