Pass DecryptConfig parameters over IPC and use it in AVDA.

content/common/gpu/media/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 "content/common/gpu/media/android_video_decode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
@@ skipping 172 matching lines @@
 
   scoped_ptr<base::SharedMemory> shm(
       new base::SharedMemory(bitstream_buffer.handle(), true));
   RETURN_ON_FAILURE(this, shm->Map(bitstream_buffer.size()),
                     "Failed to SharedMemory::Map()", UNREADABLE_INPUT);
 
   const base::TimeDelta presentation_timestamp =
       bitstream_buffer.presentation_timestamp();
   DCHECK(presentation_timestamp != media::kNoTimestamp())
       << "Bitstream buffers must have valid presentation timestamps";
+
   // There may already be a bitstream buffer with this timestamp, e.g., VP9 alt
   // ref frames, but it's OK to overwrite it because we only expect a single
   // output frame to have that timestamp. AVDA clients only use the bitstream
   // buffer id in the returned Pictures to map a bitstream buffer back to a
   // timestamp on their side, so either one of the bitstream buffer ids will
   // result in them finding the right timestamp.
   bitstream_buffers_in_decoder_[presentation_timestamp] = bitstream_buffer.id();
 
-  status = media_codec_->QueueInputBuffer(
-      input_buf_index, static_cast<const uint8*>(shm->memory()),
-      bitstream_buffer.size(), presentation_timestamp);
+  const uint8_t* memory = static_cast<const uint8_t*>(shm->memory());
+  const std::string& key_id = bitstream_buffer.key_id();
+  const std::string& iv = bitstream_buffer.iv();
+  const std::vector<media::SubsampleEntry>& subsamples =
+      bitstream_buffer.subsamples();
+
+  if (key_id.empty() || iv.empty()) {
+    status = media_codec_->QueueInputBuffer(input_buf_index, memory,
+                                            bitstream_buffer.size(),
+                                            presentation_timestamp);
+  } else {
+    status = media_codec_->QueueSecureInputBuffer(

[dcheng, 2015/10/23 00:44:47]

Why doesn't this function just take std::string for the key + IV and a
std::vector<media::SubsampleEntry> for the subsamples?

The other callers have to jump through these hoops too, so may as well make it
internal to the function.

[Tima Vaisburd, 2015/10/23 18:51:40]

I think because this function was designed to work with AccessUnit
https://code.google.com/p/chromium/codesearch#chromium/src/media/base/android...

I added an override that calls the existing one and TODO that only one should
stay after Spitzer pipeline prevails.

+        input_buf_index, memory, bitstream_buffer.size(),
+        reinterpret_cast<const uint8_t*>(key_id.data()), key_id.size(),
+        reinterpret_cast<const uint8_t*>(iv.data()), iv.size(),
+        subsamples.empty() ? nullptr : &subsamples[0], subsamples.size(),
+        presentation_timestamp);
+  }
+
+  DVLOG(2) << __FUNCTION__
+           << ": QueueInputBuffer: pts:" << presentation_timestamp
+           << " status:" << status;
+
   RETURN_ON_FAILURE(this, status == media::MEDIA_CODEC_OK,
                     "Failed to QueueInputBuffer: " << status, PLATFORM_FAILURE);
 
   // We should call NotifyEndOfBitstreamBuffer(), when no more decoded output
   // will be returned from the bitstream buffer. However, MediaCodec API is
   // not enough to guarantee it.
   // So, here, we calls NotifyEndOfBitstreamBuffer() in advance in order to
   // keep getting more bitstreams from the client, and throttle them by using
   // |bitstreams_notified_in_advance_|.
   // TODO(dwkang): check if there is a way to remove this workaround.
@@ skipping 24 matching lines @@
     size_t offset = 0;
     size_t size = 0;
 
     TRACE_EVENT_BEGIN0("media", "AVDA::DequeueOutputBuffer");
     media::MediaCodecStatus status = media_codec_->DequeueOutputBuffer(
         NoWaitTimeOut(), &buf_index, &offset, &size, &presentation_timestamp,
         &eos, NULL);
     TRACE_EVENT_END2("media", "AVDA::DequeueOutputBuffer", "status", status,
                      "presentation_timestamp (ms)",
                      presentation_timestamp.InMilliseconds());
+
+    DVLOG(3) << "AVDA::DequeueOutputBuffer: pts:" << presentation_timestamp
+             << " buf_index:" << buf_index << " offset:" << offset
+             << " size:" << size << " eos:" << eos;
+
     switch (status) {
       case media::MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER:
       case media::MEDIA_CODEC_ERROR:
         return false;
 
       case media::MEDIA_CODEC_OUTPUT_FORMAT_CHANGED: {
         int32 width, height;
         media_codec_->GetOutputFormat(&width, &height);
 
         if (!picturebuffers_requested_) {
@@ skipping 22 matching lines @@
       case media::MEDIA_CODEC_OK:
         DCHECK_GE(buf_index, 0);
         break;
 
       default:
         NOTREACHED();
         break;
     }
   } while (buf_index < 0);
 
-  if (eos) {
+  // Normaly we assume that the decoder makes at most one output frame for each

[watk, 2015/10/22 22:49:26]

"Normally"

[Tima Vaisburd, 2015/10/23 18:51:40]

Done.

+  // distinct input timestamp. A VP9 alt ref frame is a case where an input
+  // buffer, with a possibly unique timestamp, will not result in a
+  // corresponding output frame.
+
+  // However MediaCodecBridge uses timestamp correction and provides
+  // non-decreasing timestamp sequence, which might result in timestamp
+  // duplicates. Discard the frame if we cannot get corresponding buffer id.
+
+  // Get the bitstream buffer id from the timestamp.
+  auto it = eos ? bitstream_buffers_in_decoder_.end()
+                : bitstream_buffers_in_decoder_.find(presentation_timestamp);
+
+  if (it == bitstream_buffers_in_decoder_.end()) {
     media_codec_->ReleaseOutputBuffer(buf_index, false);
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&AndroidVideoDecodeAccelerator::NotifyFlushDone,
                    weak_this_factory_.GetWeakPtr()));
   } else {
-    // Get the bitstream buffer id from the timestamp.
-    auto it = bitstream_buffers_in_decoder_.find(presentation_timestamp);
-    // Require the decoder to output at most one frame for each distinct input
-    // buffer timestamp. A VP9 alt ref frame is a case where an input buffer,
-    // with a possibly unique timestamp, will not result in a corresponding
-    // output frame.
-    CHECK(it != bitstream_buffers_in_decoder_.end())
-        << "Unexpected output frame timestamp";
     const int32 bitstream_buffer_id = it->second;
     bitstream_buffers_in_decoder_.erase(bitstream_buffers_in_decoder_.begin(),
                                         ++it);
     SendCurrentSurfaceToClient(buf_index, bitstream_buffer_id);
 
     // If we decoded a frame this time, then try for another.
     should_try_again = true;
 
     // Removes ids former or equal than the id from decoder. Note that
     // |bitstreams_notified_in_advance_| does not mean bitstream ids in decoder
@@ skipping 296 matching lines @@
     // software fallback for H264 on Android anyway.
     profile.max_resolution.SetSize(3840, 2160);
     profiles.push_back(profile);
   }
 #endif
 
   return profiles;
 }
 
 }  // namespace content