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.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 74 matching lines @@
 // For RecordFormatChangedMetric.
 enum FormatChangedValue {
   CodecInitialized = false,
   MissingFormatChanged = true
 };
 
 inline void RecordFormatChangedMetric(FormatChangedValue value) {
   UMA_HISTOGRAM_BOOLEAN("Media.AVDA.MissingFormatChanged", !!value);
 }
 
+// Extract the SPS and PPS from |extra_data| (which should be an AVCC) and write
+// them to |csd0| and |csd1|, respectively, in the format MediaCodec expects.
+// Returns true on success. The out parameters are not modified on failure.
+bool ExtractSpsAndPps(const std::vector<uint8_t>& extra_data,
+                      std::vector<uint8_t>* csd0,
+                      std::vector<uint8_t>* csd1) {
+  mp4::AVCDecoderConfigurationRecord record;
+  if (!record.Parse(extra_data.data(), extra_data.size()))
+    return false;
+
+  const std::array<uint8_t, 4> prefix = {0, 0, 0, 1};

[dcheng, 2016/09/27 22:41:15]

constexpr

[watk, 2016/09/27 22:56:02]

Done.

+  for (const std::vector<uint8_t>& sps : record.sps_list) {
+    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) {
+    csd1->insert(csd1->end(), prefix.begin(), prefix.end());
+    csd1->insert(csd1->end(), pps.begin(), pps.end());
+  }
+
+  return true;
+}
+
 }  // namespace
 
 // AVDAManager manages shared resources for a number of AVDA instances.
 // Its responsibilities include:
 //  - Starting and stopping a shared "construction" thread for instantiating and
 //    releasing MediaCodecs.
 //  - Detecting when a task has hung on the construction thread so AVDAs can
 //    stop using it.
 //  - Running a RepeatingTimer so that AVDAs can get a regular callback to
 //    DoIOTask().
@@ skipping 341 matching lines @@
   codec_config_->codec_ = VideoCodecProfileToVideoCodec(config.profile);
   codec_config_->initial_expected_coded_size_ =
       config.initial_expected_coded_size;
 
   if (codec_config_->codec_ != kCodecVP8 &&
       codec_config_->codec_ != kCodecVP9 &&
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
       codec_config_->codec_ != kCodecHEVC &&
 #endif
       codec_config_->codec_ != kCodecH264) {
-    LOG(ERROR) << "Unsupported profile: " << config.profile;
+    DLOG(ERROR) << "Unsupported profile: " << config.profile;
     return false;
   }
 
   // Only use MediaCodec for VP8/9 if it's likely backed by hardware
   // 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;
   }
 
+  if (codec_config_->codec_ == kCodecH264 && !config.extra_data.empty()) {
+    if (!ExtractSpsAndPps(config.extra_data, &codec_config_->csd0_,
+                          &codec_config_->csd1_)) {
+      DLOG(ERROR) << "Failed to parse extra_data as an AVCC.";
+      return false;
+    }
+  }
+
   auto gles_decoder = get_gles2_decoder_cb_.Run();
   if (!gles_decoder) {
-    LOG(ERROR) << "Failed to get gles2 decoder instance.";
+    DLOG(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_)) {
     DCHECK(!deferred_initialization_pending_);
 
     // We should never be here if a SurfaceView is required.
@@ skipping 620 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 538 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