media/gpu/AVD: Take DecoderBuffer in AVD::SetStream()'s argument

This changes AcceleratedVideoDecoder::SetStream() argument to DecoderBuffer.
DecoderBuffer has any required information to decode. It may have additional
info that is specifically necessary in AcceleratedVideoDecoder. For instance, it
has frame sizes of spatial layers in VP9 SVC stream aside from bitstream data.
This is a second step to enable VP9 k-SVC decoding with HW decoder on chromeos
intel platform.

Design doc for this change is go/VP9-k-SVC-Decoing-VAAPI.

Bug: chromium:935411
Test: media_unittests
Test: Hangout Meet with VP9 SVC stream
Change-Id: I45ca9e6ea7e7c6b8ac619495049be51fa9aed486
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1686981
Commit-Queue: Hirokazu Honda <hiroh@chromium.org>
Reviewed-by: Ted Meyer <tmathmeyer@chromium.org>
Reviewed-by: Dale Curtis <dalecurtis@chromium.org>
Cr-Commit-Position: refs/heads/master@{#675637}

diff --git a/media/gpu/accelerated_video_decoder.h b/media/gpu/accelerated_video_decoder.h
index 11c4ad9..71e8ecd 100644
--- a/media/gpu/accelerated_video_decoder.h
+++ b/media/gpu/accelerated_video_decoder.h

@@ -9,7 +9,7 @@
 #include <stdint.h>
 
 #include "base/macros.h"
-#include "media/base/decrypt_config.h"
+#include "media/base/decoder_buffer.h"
 #include "media/gpu/media_gpu_export.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
@@ -25,15 +25,12 @@
   AcceleratedVideoDecoder() {}
   virtual ~AcceleratedVideoDecoder() {}
 
-  // Set the buffer at |ptr| of |size| bytes as the current source of encoded
-  // stream data. Pictures produced as a result of this call should be assigned
-  // the passed stream |id|. |decrypt_config| may specify the decryption
-  // configuration of the specified buffer, and in that case, Decode() may
-  // return kNoKey.
-  virtual void SetStream(int32_t id,
-                         const uint8_t* ptr,
-                         size_t size,
-                         const DecryptConfig* decrypt_config = nullptr) = 0;
+  // Set the buffer owned by |decoder_buffer| as the current source of encoded
+  // stream data. AcceleratedVideoDecoder doesn't have an ownership of the
+  // buffer. |decoder_buffer| must be kept alive until Decode() returns
+  // kRanOutOfStreamData. Pictures produced as a result of this call should be
+  // assigned the passed stream |id|.
+  virtual void SetStream(int32_t id, const DecoderBuffer& decoder_buffer) = 0;
 
   // Have the decoder flush its state and trigger output of all previously
   // decoded surfaces. Return false on failure.

diff --git a/media/gpu/h264_decoder.cc b/media/gpu/h264_decoder.cc
index f621695..f668b1d2 100644
--- a/media/gpu/h264_decoder.cc
+++ b/media/gpu/h264_decoder.cc

@@ -1223,13 +1223,13 @@
     }                                              \
   } while (0)
 
-void H264Decoder::SetStream(int32_t id,
-                            const uint8_t* ptr,
-                            size_t size,
-                            const DecryptConfig* decrypt_config) {
+void H264Decoder::SetStream(int32_t id, const DecoderBuffer& decoder_buffer) {
+  const uint8_t* ptr = decoder_buffer.data();
+  const size_t size = decoder_buffer.data_size();
+  const DecryptConfig* decrypt_config = decoder_buffer.decrypt_config();
+
   DCHECK(ptr);
   DCHECK(size);
-
   DVLOG(4) << "New input stream id: " << id << " at: " << (void*)ptr
            << " size: " << size;
   stream_id_ = id;

diff --git a/media/gpu/h264_decoder.h b/media/gpu/h264_decoder.h
index 0c8250f..3c63df6 100644
--- a/media/gpu/h264_decoder.h
+++ b/media/gpu/h264_decoder.h

@@ -151,10 +151,7 @@
   ~H264Decoder() override;
 
   // AcceleratedVideoDecoder implementation.
-  void SetStream(int32_t id,
-                 const uint8_t* ptr,
-                 size_t size,
-                 const DecryptConfig* decrypt_config = nullptr) override;
+  void SetStream(int32_t id, const DecoderBuffer& decoder) override;
   bool Flush() override WARN_UNUSED_RESULT;
   void Reset() override;
   DecodeResult Decode() override WARN_UNUSED_RESULT;

diff --git a/media/gpu/h264_decoder_unittest.cc b/media/gpu/h264_decoder_unittest.cc
index d4d94a2..86f26e30 100644
--- a/media/gpu/h264_decoder_unittest.cc
+++ b/media/gpu/h264_decoder_unittest.cc

@@ -156,6 +156,7 @@
  private:
   base::queue<std::string> input_frame_files_;
   std::string bitstream_;
+  scoped_refptr<DecoderBuffer> decoder_buffer_;
 };
 
 void H264DecoderTest::SetUp() {
@@ -196,9 +197,10 @@
     auto input_file = GetTestDataFilePath(input_frame_files_.front());
     input_frame_files_.pop();
     CHECK(base::ReadFileToString(input_file, &bitstream_));
-    decoder_->SetStream(bitstream_id++,
-                        reinterpret_cast<const uint8_t*>(bitstream_.data()),
-                        bitstream_.size());
+    decoder_buffer_ = DecoderBuffer::CopyFrom(
+        reinterpret_cast<const uint8_t*>(bitstream_.data()), bitstream_.size());
+    EXPECT_NE(decoder_buffer_.get(), nullptr);
+    decoder_->SetStream(bitstream_id++, *decoder_buffer_);
   }
 }
 
@@ -445,8 +447,11 @@
               SubmitDecode(DecryptConfigMatches(decrypt_config.get())))
       .WillOnce(Return(H264Decoder::H264Accelerator::Status::kOk));
 
-  decoder_->SetStream(0, reinterpret_cast<const uint8_t*>(bitstream.data()),
-                      bitstream.size(), decrypt_config.get());
+  auto buffer = DecoderBuffer::CopyFrom(
+      reinterpret_cast<const uint8_t*>(bitstream.data()), bitstream.size());
+  ASSERT_NE(buffer.get(), nullptr);
+  buffer->set_decrypt_config(std::move(decrypt_config));
+  decoder_->SetStream(0, *buffer);
   EXPECT_EQ(AcceleratedVideoDecoder::kAllocateNewSurfaces, decoder_->Decode());
   EXPECT_EQ(AcceleratedVideoDecoder::kRanOutOfStreamData, decoder_->Decode());
   EXPECT_TRUE(decoder_->Flush());

diff --git a/media/gpu/v4l2/v4l2_slice_video_decode_accelerator.cc b/media/gpu/v4l2/v4l2_slice_video_decode_accelerator.cc
index 2fdc917..a7eb6b1 100644
--- a/media/gpu/v4l2/v4l2_slice_video_decode_accelerator.cc
+++ b/media/gpu/v4l2/v4l2_slice_video_decode_accelerator.cc

@@ -1104,12 +1104,8 @@
     return false;
   }
 
-  const uint8_t* const data = decoder_current_bitstream_buffer_->buffer->data();
-  const size_t data_size =
-      decoder_current_bitstream_buffer_->buffer->data_size();
-  decoder_->SetStream(decoder_current_bitstream_buffer_->input_id, data,
-                      data_size);
-
+  decoder_->SetStream(decoder_current_bitstream_buffer_->input_id,
+                      *decoder_current_bitstream_buffer_->buffer);
   return true;
 }
 

diff --git a/media/gpu/v4l2/v4l2_slice_video_decoder.cc b/media/gpu/v4l2/v4l2_slice_video_decoder.cc
index ef110a37..b984c70 100644
--- a/media/gpu/v4l2/v4l2_slice_video_decoder.cc
+++ b/media/gpu/v4l2/v4l2_slice_video_decoder.cc

@@ -607,8 +607,7 @@
         }
 
         avd_->SetStream(current_decode_request_->bitstream_id,
-                        current_decode_request_->buffer->data(),
-                        current_decode_request_->buffer->data_size());
+                        *current_decode_request_->buffer);
         break;
 
       case AcceleratedVideoDecoder::kRanOutOfSurfaces:

diff --git a/media/gpu/vaapi/vaapi_video_decode_accelerator.cc b/media/gpu/vaapi/vaapi_video_decode_accelerator.cc
index 69859ee..f1231e3 100644
--- a/media/gpu/vaapi/vaapi_video_decode_accelerator.cc
+++ b/media/gpu/vaapi/vaapi_video_decode_accelerator.cc

@@ -389,10 +389,7 @@
 
   DVLOGF(4) << "New |curr_input_buffer_|, id: " << curr_input_buffer_->id()
             << " size: " << curr_input_buffer_->buffer()->data_size() << "B";
-  decoder_->SetStream(curr_input_buffer_->id(),
-                      curr_input_buffer_->buffer()->data(),
-                      curr_input_buffer_->buffer()->data_size());
-
+  decoder_->SetStream(curr_input_buffer_->id(), *curr_input_buffer_->buffer());
   return true;
 }
 
@@ -512,7 +509,6 @@
 
   requested_pic_size_ = size;
   requested_visible_rect_ = visible_rect;
-
   if (buffer_allocation_mode_ == BufferAllocationMode::kSuperReduced) {
     // Add one to the reference frames for the one being currently egressed.
     requested_num_reference_frames_ = num_reference_frames + 1;

diff --git a/media/gpu/vaapi/vaapi_video_decode_accelerator_unittest.cc b/media/gpu/vaapi/vaapi_video_decode_accelerator_unittest.cc
index 728a94d8..8dc6f4bf 100644
--- a/media/gpu/vaapi/vaapi_video_decode_accelerator_unittest.cc
+++ b/media/gpu/vaapi/vaapi_video_decode_accelerator_unittest.cc

@@ -46,6 +46,9 @@
 constexpr size_t kNewNumPictures = 3;
 const gfx::Size kNewPictureSize(64, 48);
 
+MATCHER_P2(IsExpectedDecoderBuffer, data_size, decrypt_config, "") {
+  return arg.data_size() == data_size && arg.decrypt_config() == decrypt_config;
+}
 }  // namespace
 
 class MockAcceleratedVideoDecoder : public AcceleratedVideoDecoder {
@@ -53,9 +56,7 @@
   MockAcceleratedVideoDecoder() = default;
   ~MockAcceleratedVideoDecoder() override = default;
 
-  MOCK_METHOD4(
-      SetStream,
-      void(int32_t id, const uint8_t* ptr, size_t size, const DecryptConfig*));
+  MOCK_METHOD2(SetStream, void(int32_t id, const DecoderBuffer&));
   MOCK_METHOD0(Flush, bool());
   MOCK_METHOD0(Reset, void());
   MOCK_METHOD0(Decode, DecodeResult());
@@ -219,7 +220,9 @@
     ::testing::InSequence s;
     base::RunLoop run_loop;
     base::Closure quit_closure = run_loop.QuitClosure();
-    EXPECT_CALL(*mock_decoder_, SetStream(_, _, kInputSize, nullptr));
+    EXPECT_CALL(*mock_decoder_,
+                SetStream(_, IsExpectedDecoderBuffer(kInputSize, nullptr)))
+        .WillOnce(Return());
     EXPECT_CALL(*mock_decoder_, Decode())
         .WillOnce(Return(AcceleratedVideoDecoder::kAllocateNewSurfaces));
 
@@ -330,7 +333,9 @@
   void DecodeOneFrameFast(int32_t bitstream_id) {
     base::RunLoop run_loop;
     base::Closure quit_closure = run_loop.QuitClosure();
-    EXPECT_CALL(*mock_decoder_, SetStream(_, _, kInputSize, nullptr));
+    EXPECT_CALL(*mock_decoder_,
+                SetStream(_, IsExpectedDecoderBuffer(kInputSize, nullptr)))
+        .WillOnce(Return());
     EXPECT_CALL(*mock_decoder_, Decode())
         .WillOnce(Return(AcceleratedVideoDecoder::kRanOutOfStreamData));
     EXPECT_CALL(*this, NotifyEndOfBitstreamBuffer(bitstream_id))
@@ -414,7 +419,9 @@
 
   base::RunLoop run_loop;
   base::Closure quit_closure = run_loop.QuitClosure();
-  EXPECT_CALL(*mock_decoder_, SetStream(_, _, kInputSize, nullptr));
+  EXPECT_CALL(*mock_decoder_,
+              SetStream(_, IsExpectedDecoderBuffer(kInputSize, nullptr)))
+      .WillOnce(Return());
   EXPECT_CALL(*mock_decoder_, Decode())
       .WillOnce(Return(AcceleratedVideoDecoder::kDecodeError));
   EXPECT_CALL(*this, NotifyError(VaapiVideoDecodeAccelerator::PLATFORM_FAILURE))

diff --git a/media/gpu/vaapi/vaapi_video_decoder.cc b/media/gpu/vaapi/vaapi_video_decoder.cc
index cbf279e..e5ad316 100644
--- a/media/gpu/vaapi/vaapi_video_decoder.cc
+++ b/media/gpu/vaapi/vaapi_video_decoder.cc

@@ -320,8 +320,7 @@
   decode_task_queue_.pop();
   if (!current_decode_task_->buffer_->end_of_stream()) {
     decoder_->SetStream(current_decode_task_->buffer_id_,
-                        current_decode_task_->buffer_->data(),
-                        current_decode_task_->buffer_->data_size());
+                        *current_decode_task_->buffer_);
   }
 
   decoder_thread_task_runner_->PostTask(

diff --git a/media/gpu/vaapi/vaapi_vp9_accelerator.cc b/media/gpu/vaapi/vaapi_vp9_accelerator.cc
index 8ab85af..9896fb23 100644
--- a/media/gpu/vaapi/vaapi_vp9_accelerator.cc
+++ b/media/gpu/vaapi/vaapi_vp9_accelerator.cc

@@ -57,7 +57,6 @@
   pic_param.frame_width = base::checked_cast<uint16_t>(frame_hdr->frame_width);
   pic_param.frame_height =
       base::checked_cast<uint16_t>(frame_hdr->frame_height);
-
   CHECK_EQ(kVp9NumRefFrames, base::size(pic_param.reference_frames));
   for (size_t i = 0; i < base::size(pic_param.reference_frames); ++i) {
     auto ref_pic = ref_frames.GetFrame(i);

diff --git a/media/gpu/vp8_decoder.cc b/media/gpu/vp8_decoder.cc
index 840b5fa..f5caa31 100644
--- a/media/gpu/vp8_decoder.cc
+++ b/media/gpu/vp8_decoder.cc

@@ -31,10 +31,11 @@
   return true;
 }
 
-void VP8Decoder::SetStream(int32_t id,
-                           const uint8_t* ptr,
-                           size_t size,
-                           const DecryptConfig* decrypt_config) {
+void VP8Decoder::SetStream(int32_t id, const DecoderBuffer& decoder_buffer) {
+  const uint8_t* ptr = decoder_buffer.data();
+  const size_t size = decoder_buffer.data_size();
+  const DecryptConfig* decrypt_config = decoder_buffer.decrypt_config();
+
   DCHECK(ptr);
   DCHECK(size);
   if (decrypt_config) {

diff --git a/media/gpu/vp8_decoder.h b/media/gpu/vp8_decoder.h
index ecc77310..61a0031 100644
--- a/media/gpu/vp8_decoder.h
+++ b/media/gpu/vp8_decoder.h

@@ -63,10 +63,7 @@
   ~VP8Decoder() override;
 
   // AcceleratedVideoDecoder implementation.
-  void SetStream(int32_t id,
-                 const uint8_t* ptr,
-                 size_t size,
-                 const DecryptConfig* decrypt_config = nullptr) override;
+  void SetStream(int32_t id, const DecoderBuffer& decoder_buffer) override;
   bool Flush() override WARN_UNUSED_RESULT;
   void Reset() override;
   DecodeResult Decode() override WARN_UNUSED_RESULT;

diff --git a/media/gpu/vp8_decoder_unittest.cc b/media/gpu/vp8_decoder_unittest.cc
index deee372..67d8c4b 100644
--- a/media/gpu/vp8_decoder_unittest.cc
+++ b/media/gpu/vp8_decoder_unittest.cc

@@ -100,15 +100,27 @@
 AcceleratedVideoDecoder::DecodeResult VP8DecoderTest::Decode(
     std::string input_frame_file) {
   std::string bitstream;
+  scoped_refptr<DecoderBuffer> buffer;
   if (!input_frame_file.empty()) {
     auto input_file = GetTestDataFilePath(input_frame_file);
     EXPECT_TRUE(base::ReadFileToString(input_file, &bitstream));
-    decoder_->SetStream(bitstream_id_++,
-                        reinterpret_cast<const uint8_t*>(bitstream.data()),
-                        bitstream.size());
+    buffer = DecoderBuffer::CopyFrom(
+        reinterpret_cast<const uint8_t*>(bitstream.data()), bitstream.size());
+    EXPECT_NE(buffer.get(), nullptr);
+    decoder_->SetStream(bitstream_id_++, *buffer);
   }
 
-  return decoder_->Decode();
+  AcceleratedVideoDecoder::DecodeResult result = decoder_->Decode();
+  if (input_frame_file.empty())
+    return result;
+  // Since |buffer| is destroyed in this function, Decode() must consume the
+  // buffer by this Decode(). That happens if the return value is
+  // kRanOutOfStreamData, kAllocateNewSurfaces , or kDecodeError (on failure).
+  EXPECT_TRUE(
+      result == AcceleratedVideoDecoder::DecodeResult::kRanOutOfStreamData ||
+      result == AcceleratedVideoDecoder::DecodeResult::kAllocateNewSurfaces ||
+      result == AcceleratedVideoDecoder::DecodeResult::kDecodeError);
+  return result;
 }
 
 // Test Cases

diff --git a/media/gpu/vp9_decoder.cc b/media/gpu/vp9_decoder.cc
index 6cb9071..4927308 100644
--- a/media/gpu/vp9_decoder.cc
+++ b/media/gpu/vp9_decoder.cc

@@ -27,10 +27,11 @@
 
 VP9Decoder::~VP9Decoder() = default;
 
-void VP9Decoder::SetStream(int32_t id,
-                           const uint8_t* ptr,
-                           size_t size,
-                           const DecryptConfig* decrypt_config) {
+void VP9Decoder::SetStream(int32_t id, const DecoderBuffer& decoder_buffer) {
+  const uint8_t* ptr = decoder_buffer.data();
+  const size_t size = decoder_buffer.data_size();
+  const DecryptConfig* decrypt_config = decoder_buffer.decrypt_config();
+
   DCHECK(ptr);
   DCHECK(size);
   DVLOG(4) << "New input stream id: " << id << " at: " << (void*)ptr

diff --git a/media/gpu/vp9_decoder.h b/media/gpu/vp9_decoder.h
index 0bc33f0..6a0c357d 100644
--- a/media/gpu/vp9_decoder.h
+++ b/media/gpu/vp9_decoder.h

@@ -18,6 +18,7 @@
 #include "media/gpu/accelerated_video_decoder.h"
 #include "media/gpu/vp9_picture.h"
 #include "media/gpu/vp9_reference_frame_vector.h"
+#include "ui/gfx/geometry/size.h"
 
 namespace media {
 
@@ -98,10 +99,7 @@
   ~VP9Decoder() override;
 
   // AcceleratedVideoDecoder implementation.
-  void SetStream(int32_t id,
-                 const uint8_t* ptr,
-                 size_t size,
-                 const DecryptConfig* decrypt_config = nullptr) override;
+  void SetStream(int32_t id, const DecoderBuffer& decoder_buffer) override;
   bool Flush() override WARN_UNUSED_RESULT;
   void Reset() override;
   DecodeResult Decode() override WARN_UNUSED_RESULT;

diff --git a/media/gpu/windows/d3d11_video_decoder.cc b/media/gpu/windows/d3d11_video_decoder.cc
index 9987c03..29cbc67 100644
--- a/media/gpu/windows/d3d11_video_decoder.cc
+++ b/media/gpu/windows/d3d11_video_decoder.cc

@@ -463,9 +463,7 @@
     // EOS buffer.
     current_timestamp_ = current_buffer_->timestamp();
 
-    accelerated_video_decoder_->SetStream(-1, current_buffer_->data(),
-                                          current_buffer_->data_size(),
-                                          current_buffer_->decrypt_config());
+    accelerated_video_decoder_->SetStream(-1, *current_buffer_);
   }
 
   while (true) {