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

media/filters/vp9_parser.cc

 // Copyright 2015 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.
 //
 // This file contains an implementation of a VP9 bitstream parser.
 //
 // VERBOSE level:
 //  1 something wrong in bitstream
 //  2 parsing steps
 //  3 parsed values (selected)
@@ skipping 18 matching lines @@
   return !show_existing_frame && frame_type == KEYFRAME;
 }
 
 bool Vp9FrameHeader::IsIntra() const {
   return !show_existing_frame && (frame_type == KEYFRAME || intra_only);
 }
 
 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");
   if (memchr(context.tx_probs_8x8, 0, sizeof(context.tx_probs_8x8)))
     return false;
   if (memchr(context.tx_probs_16x16, 0, sizeof(context.tx_probs_16x16)))
     return false;
   if (memchr(context.tx_probs_32x32, 0, sizeof(context.tx_probs_32x32)))
     return false;
 
@@ skipping 48 matching lines @@
   if (memchr(context.mv_fr_probs, 0, sizeof(context.mv_fr_probs)))
     return false;
   if (memchr(context.mv_class0_hp_prob, 0, sizeof(context.mv_class0_hp_prob)))
     return false;
   if (memchr(context.mv_hp_prob, 0, sizeof(context.mv_hp_prob)))
     return false;
 
   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());
 }
 
-void Vp9FrameContextManager::Update(const Vp9FrameContext& frame_context) {
+Vp9Parser::ContextRefreshCallback
+Vp9Parser::Context::Vp9FrameContextManager::GetUpdateCb() {
+  if (needs_client_update_)
+    return base::Bind(&Vp9FrameContextManager::UpdateFromClient,
+                      weak_ptr_factory_.GetWeakPtr());
+  else
+    return Vp9Parser::ContextRefreshCallback();
+}
+
+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;
 
   // For frame context we are updating, it may be still awaiting previous
   // ContextRefreshCallback. Because we overwrite the value of context here and
   // previous ContextRefreshCallback no longer matters, invalidate the weak ptr
   // to prevent previous ContextRefreshCallback run.
   // With this optimization, we may be able to parse more frames while previous
   // are still decoding.
   weak_ptr_factory_.InvalidateWeakPtrs();
   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;
   }
   needs_client_update_ = false;
   initialized_ = true;
   frame_context_ = frame_context;
 }
 
 void Vp9Parser::Context::Reset() {
   memset(&segmentation, 0, sizeof(segmentation));
   memset(&loop_filter, 0, sizeof(loop_filter));
   memset(&ref_slots, 0, sizeof(ref_slots));
   for (auto& manager : frame_context_managers)
     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();
 }
 
 Vp9Parser::~Vp9Parser() {}
 
 void Vp9Parser::SetStream(const uint8_t* stream, off_t stream_size) {
   DCHECK(stream);
   stream_ = stream;
   bytes_left_ = stream_size;
   frames_.clear();
 }
 
 void Vp9Parser::Reset() {
   stream_ = nullptr;
   bytes_left_ = 0;
   frames_.clear();
 
   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
   // |curr_frame_header_| and we are awaiting context update to proceed with
   // compressed header parsing.
   if (!curr_frame_info_.IsValid()) {
     if (frames_.empty()) {
       // No frames to be decoded, if there is no more stream, request more.
       if (!stream_)
         return kEOStream;
@@ skipping 35 matching lines @@
       DVLOG(1) << "header_size_in_bytes="
                << curr_frame_header_.header_size_in_bytes
                << " is larger than bytes left in buffer: "
                << curr_frame_info_.size -
                       curr_frame_header_.uncompressed_header_size;
       return kInvalidStream;
     }
   }
 
   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 =
         curr_frame_header_.frame_context = context_to_load.frame_context();
 
     Vp9CompressedHeaderParser compressed_parser;
     if (!compressed_parser.Parse(
             curr_frame_info_.ptr + curr_frame_header_.uncompressed_header_size,
             curr_frame_header_.header_size_in_bytes, &curr_frame_header_)) {
       return kInvalidStream;
     }
 
     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);
       }
     }
   }
 
   SetupSegmentationDequant();
   SetupLoopFilter();
   UpdateSlots();
 
   *fhdr = curr_frame_header_;
   curr_frame_info_.Reset();
   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_;
   off_t bytes_left = bytes_left_;
 
   // Make sure we don't parse stream_ more than once.
   stream_ = nullptr;
   bytes_left_ = 0;
 
   if (bytes_left < 1)
@@ skipping 237 matching lines @@
       ref.subsampling_y = curr_frame_header_.subsampling_y;
       ref.bit_depth = curr_frame_header_.bit_depth;
 
       ref.profile = curr_frame_header_.profile;
       ref.color_space = curr_frame_header_.color_space;
     }
   }
 }
 
 }  // namespace media