V4L2SVDA: Add a VP9Accelerator implementation utilizing the V4L2 VP9 frame API.

media/filters/vp9_parser.cc

Index: media/filters/vp9_parser.cc
diff --git a/media/filters/vp9_parser.cc b/media/filters/vp9_parser.cc
index c49e33b391dff4dee3f13ca6fb0e849728f750dd..410da6b6636cd058a5f54e7621f7352fe526bf4e 100644
--- a/media/filters/vp9_parser.cc
+++ b/media/filters/vp9_parser.cc
@@ -36,12 +36,8 @@ bool Vp9FrameHeader::IsIntra() const {
 Vp9Parser::FrameInfo::FrameInfo(const uint8_t* ptr, off_t size)
     : ptr(ptr), size(size) {}
 
-Vp9FrameContextManager::Vp9FrameContextManager() : weak_ptr_factory_(this) {}
-
-Vp9FrameContextManager::~Vp9FrameContextManager() {}
-
-bool Vp9FrameContextManager::IsValidFrameContext(
-    const Vp9FrameContext& context) {
+// static
+bool Vp9FrameContext::IsValid(const Vp9FrameContext& context) {
   // probs should be in [1, 255] range.
   static_assert(sizeof(Vp9Prob) == 1,
                 "following checks assuming Vp9Prob is single byte");
@@ -110,31 +106,43 @@ bool Vp9FrameContextManager::IsValidFrameContext(
   return true;
 }
 
-const Vp9FrameContext& Vp9FrameContextManager::frame_context() const {
+Vp9Parser::Context::Vp9FrameContextManager::Vp9FrameContextManager()
+    : weak_ptr_factory_(this) {}
+
+Vp9Parser::Context::Vp9FrameContextManager::~Vp9FrameContextManager() {}
+
+const Vp9FrameContext&
+Vp9Parser::Context::Vp9FrameContextManager::frame_context() const {
   DCHECK(initialized_);
   DCHECK(!needs_client_update_);
   return frame_context_;
 }
 
-void Vp9FrameContextManager::Reset() {
+void Vp9Parser::Context::Vp9FrameContextManager::Reset() {
   initialized_ = false;
   needs_client_update_ = false;
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
-Vp9FrameContextManager::ContextRefreshCallback
-Vp9FrameContextManager::SetNeedsClientUpdate() {
+void Vp9Parser::Context::Vp9FrameContextManager::SetNeedsClientUpdate() {
   DCHECK(!needs_client_update_);
   initialized_ = true;
   needs_client_update_ = true;
+}
 
-  return base::Bind(&Vp9FrameContextManager::UpdateFromClient,
-                    weak_ptr_factory_.GetWeakPtr());
+Vp9Parser::ContextRefreshCallback
+Vp9Parser::Context::Vp9FrameContextManager::GetUpdateCb() {
+  if (needs_client_update_)
+    return base::Bind(&Vp9FrameContextManager::UpdateFromClient,
+                      weak_ptr_factory_.GetWeakPtr());
+  else
+    return Vp9Parser::ContextRefreshCallback();
 }
 
-void Vp9FrameContextManager::Update(const Vp9FrameContext& frame_context) {
+void Vp9Parser::Context::Vp9FrameContextManager::Update(
+    const Vp9FrameContext& frame_context) {
   // DCHECK because we can trust values from our parser.
-  DCHECK(IsValidFrameContext(frame_context));
+  DCHECK(Vp9FrameContext::IsValid(frame_context));
   initialized_ = true;
   frame_context_ = frame_context;
 
@@ -148,11 +156,11 @@ void Vp9FrameContextManager::Update(const Vp9FrameContext& frame_context) {
   needs_client_update_ = false;
 }
 
-void Vp9FrameContextManager::UpdateFromClient(
+void Vp9Parser::Context::Vp9FrameContextManager::UpdateFromClient(
     const Vp9FrameContext& frame_context) {
   DVLOG(2) << "Got external frame_context update";
   DCHECK(needs_client_update_);
-  if (!IsValidFrameContext(frame_context)) {
+  if (!Vp9FrameContext::IsValid(frame_context)) {
     DLOG(ERROR) << "Invalid prob value in frame_context";
     return;
   }
@@ -169,6 +177,18 @@ void Vp9Parser::Context::Reset() {
     manager.Reset();
 }
 
+void Vp9Parser::Context::MarkFrameContextForUpdate(size_t frame_context_idx) {
+  DCHECK_LT(frame_context_idx, arraysize(frame_context_managers));
+  frame_context_managers[frame_context_idx].SetNeedsClientUpdate();
+}
+
+void Vp9Parser::Context::UpdateFrameContext(
+    size_t frame_context_idx,
+    const Vp9FrameContext& frame_context) {
+  DCHECK_LT(frame_context_idx, arraysize(frame_context_managers));
+  frame_context_managers[frame_context_idx].Update(frame_context);
+}
+
 Vp9Parser::Vp9Parser(bool parsing_compressed_header)
     : parsing_compressed_header_(parsing_compressed_header) {
   Reset();
@@ -191,11 +211,8 @@ void Vp9Parser::Reset() {
   context_.Reset();
 }
 
-Vp9Parser::Result Vp9Parser::ParseNextFrame(
-    Vp9FrameHeader* fhdr,
-    Vp9FrameContextManager::ContextRefreshCallback* context_refresh_cb) {
+Vp9Parser::Result Vp9Parser::ParseNextFrame(Vp9FrameHeader* fhdr) {
   DCHECK(fhdr);
-  DCHECK(!parsing_compressed_header_ || context_refresh_cb);
   DVLOG(2) << "ParseNextFrame";
 
   // If |curr_frame_info_| is valid, uncompressed header was parsed into
@@ -251,19 +268,19 @@ Vp9Parser::Result Vp9Parser::ParseNextFrame(
   }
 
   if (parsing_compressed_header_) {
-    Vp9FrameContextManager& context_to_load =
-        context_.frame_context_managers[curr_frame_header_.frame_context_idx];
+    size_t frame_context_idx = curr_frame_header_.frame_context_idx;
+    const Context::Vp9FrameContextManager& context_to_load =
+        context_.frame_context_managers[frame_context_idx];
     if (!context_to_load.initialized()) {
       // 8.2 Frame order constraints
       // must load an initialized set of probabilities.
       DVLOG(1) << "loading uninitialized frame context, index="
-               << curr_frame_header_.frame_context_idx;
+               << frame_context_idx;
       return kInvalidStream;
     }
     if (context_to_load.needs_client_update()) {
       DVLOG(3) << "waiting frame_context_idx="
-               << static_cast<int>(curr_frame_header_.frame_context_idx)
-               << " to update";
+               << static_cast<int>(frame_context_idx) << " to update";

[kcwu, 2016/08/10 09:59:18]

no longer needed to cast for size_t.

[Pawel Osciak, 2016/08/13 01:51:30]

Done.

       return kAwaitingRefresh;
     }
     curr_frame_header_.initial_frame_context =
@@ -277,15 +294,13 @@ Vp9Parser::Result Vp9Parser::ParseNextFrame(
     }
 
     if (curr_frame_header_.refresh_frame_context) {
-      Vp9FrameContextManager& frame_context_manager =
-          context_.frame_context_managers[curr_frame_header_.frame_context_idx];
-
       // In frame parallel mode, we can refresh the context without decoding
       // tile data.
       if (curr_frame_header_.frame_parallel_decoding_mode) {
-        frame_context_manager.Update(curr_frame_header_.frame_context);
+        context_.UpdateFrameContext(frame_context_idx,
+                                    curr_frame_header_.frame_context);
       } else {
-        *context_refresh_cb = frame_context_manager.SetNeedsClientUpdate();
+        context_.MarkFrameContextForUpdate(frame_context_idx);
       }
     }
   }
@@ -299,6 +314,14 @@ Vp9Parser::Result Vp9Parser::ParseNextFrame(
   return kOk;
 }
 
+Vp9Parser::ContextRefreshCallback Vp9Parser::GetContextRefreshCb(
+    const std::unique_ptr<Vp9FrameHeader>& frame_hdr) {
+  auto& frame_context_manager =
+      context_.frame_context_managers[frame_hdr->frame_context_idx];
+
+  return frame_context_manager.GetUpdateCb();
+}
+
 // Annex B Superframes
 std::deque<Vp9Parser::FrameInfo> Vp9Parser::ParseSuperframe() {
   const uint8_t* stream = stream_;