Send the h264 SPS and PPS configuration parameters to AVDA

media/gpu/android_video_decode_accelerator.cc

 // Copyright (c) 2013 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/gpu/android_video_decode_accelerator.h"
 
 #include <stddef.h>
 
+#include <array>
 #include <memory>
 
 #include "base/android/build_info.h"
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/ipc/service/gpu_channel.h"
 #include "media/base/android/media_codec_bridge.h"
 #include "media/base/android/media_codec_util.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/limits.h"
 #include "media/base/media.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_decoder_config.h"
+#include "media/formats/mp4/box_definitions.h"
 #include "media/gpu/avda_picture_buffer_manager.h"
 #include "media/gpu/shared_memory_region.h"
 #include "media/video/picture.h"
 #include "ui/gl/android/scoped_java_surface.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/gl_bindings.h"
 
 #if defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
 #include "media/mojo/services/mojo_cdm_service.h"
 #endif
@@ skipping 450 matching lines @@
   // or if the stream is encrypted.
   if (IsMediaCodecSoftwareDecodingForbidden() &&
       VideoCodecBridge::IsKnownUnaccelerated(codec_config_->codec_,
                                              MEDIA_CODEC_DECODER)) {
     DVLOG(1) << "Initialization failed: "
              << (codec_config_->codec_ == kCodecVP8 ? "vp8" : "vp9")
              << " is not hardware accelerated";
     return false;
   }
 
+  SetCsd(config.extra_data);
+
   auto gles_decoder = get_gles2_decoder_cb_.Run();
   if (!gles_decoder) {
     LOG(ERROR) << "Failed to get gles2 decoder instance.";
     return false;
   }
 
   // If we're low on resources, we may decide to defer creation of the surface
   // until the codec is actually used.
   if (g_avda_manager.Get().ShouldDeferSurfaceCreation(config_.surface_id,
                                                       codec_config_->codec_)) {
@@ skipping 623 matching lines @@
                              : nullptr;
 
   // |needs_protected_surface_| implies encrypted stream.
   DCHECK(!codec_config->needs_protected_surface_ || media_crypto);
 
   const bool require_software_codec = !codec_config->allow_autodetection_;
 
   std::unique_ptr<VideoCodecBridge> codec(VideoCodecBridge::CreateDecoder(
       codec_config->codec_, codec_config->needs_protected_surface_,
       codec_config->initial_expected_coded_size_,
-      codec_config->surface_.j_surface().obj(), media_crypto, true,
-      require_software_codec));
+      codec_config->surface_.j_surface().obj(), media_crypto,
+      codec_config->csd0_, codec_config->csd1_, true, require_software_codec));
 
   return codec;
 }
 
 void AndroidVideoDecodeAccelerator::OnCodecConfigured(
     std::unique_ptr<VideoCodecBridge> media_codec) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(state_ == WAITING_FOR_CODEC || state_ == SURFACE_DESTROYED);
 
   // Record one instance of the codec being initialized.
@@ skipping 431 matching lines @@
   // the stored value as a proxy for whether the MediaCodec is software backed
   // or not.
   if (!codec_config_->allow_autodetection_) {
     media_codec_.reset();
   } else {
     g_avda_manager.Get().ConstructionTaskRunner()->DeleteSoon(
         FROM_HERE, media_codec_.release());
   }
 }
 
+void AndroidVideoDecodeAccelerator::SetCsd(
+    const std::vector<uint8_t>& extra_data) {
+  DCHECK_NE(codec_config_->codec_, kUnknownVideoCodec);
+
+  // We currently only set csd for H264.
+  if (codec_config_->codec_ != kCodecH264 || extra_data.empty())

[sandersd (OOO until July 31), 2016/09/27 20:03:16]

I don't like this dependency, it seems to me that this should be passed in. (And
I might rename the method to ExtractCsd, or even Initialize_ExtractCsd to make
its purpose more clear.)

[watk, 2016/09/27 21:44:36]

Done.

+    return;
+
+  mp4::AVCDecoderConfigurationRecord record;
+  if (!record.Parse(extra_data.data(), extra_data.size())) {
+    DVLOG(1) << "Failed to parse the AVCC.";
+    return;

[sandersd (OOO until July 31), 2016/09/27 20:03:16]

Perhaps we should return a bool? Explicitly ignoring the result is reasonable
(with a comment), but this data should always be correct.

[watk, 2016/09/27 21:44:36]

Done.

+  }
+
+  const std::array<uint8_t, 4> prefix = {0, 0, 0, 1};
+  for (const std::vector<uint8_t>& sps : record.sps_list) {
+    auto& csd0 = codec_config_->csd0_;
+    csd0.insert(csd0.end(), prefix.begin(), prefix.end());
+    csd0.insert(csd0.end(), sps.begin(), sps.end());
+  }
+
+  for (const std::vector<uint8_t>& pps : record.pps_list) {
+    auto& csd1 = codec_config_->csd1_;
+    csd1.insert(csd1.end(), prefix.begin(), prefix.end());
+    csd1.insert(csd1.end(), pps.begin(), pps.end());
+  }
+}
+
 // static
 VideoDecodeAccelerator::Capabilities
 AndroidVideoDecodeAccelerator::GetCapabilities(
     const gpu::GpuPreferences& gpu_preferences) {
   Capabilities capabilities;
   SupportedProfiles& profiles = capabilities.supported_profiles;
 
   if (MediaCodecUtil::IsVp8DecoderAvailable()) {
     SupportedProfile profile;
     profile.profile = VP8PROFILE_ANY;
@@ skipping 87 matching lines @@
 
 bool AndroidVideoDecodeAccelerator::IsMediaCodecSoftwareDecodingForbidden()
     const {
   // Prevent MediaCodec from using its internal software decoders when we have
   // more secure and up to date versions in the renderer process.
   return !config_.is_encrypted && (codec_config_->codec_ == kCodecVP8 ||
                                    codec_config_->codec_ == kCodecVP9);
 }
 
 }  // namespace media