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) {
+bool Vp9FrameContext::IsValid() const {
   // 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)))
+  if (memchr(tx_probs_8x8, 0, sizeof(tx_probs_8x8)))
     return false;
-  if (memchr(context.tx_probs_16x16, 0, sizeof(context.tx_probs_16x16)))
+  if (memchr(tx_probs_16x16, 0, sizeof(tx_probs_16x16)))
     return false;
-  if (memchr(context.tx_probs_32x32, 0, sizeof(context.tx_probs_32x32)))
+  if (memchr(tx_probs_32x32, 0, sizeof(tx_probs_32x32)))
     return false;
 
-  for (auto& a : context.coef_probs) {
+  for (auto& a : coef_probs) {
     for (auto& ai : a) {
       for (auto& aj : ai) {
         for (auto& ak : aj) {
           int max_l = (ak == aj[0]) ? 3 : 6;
           for (int l = 0; l < max_l; l++) {
             for (auto& x : ak[l]) {
               if (x == 0)
                 return false;
             }
           }
         }
       }
     }
   }
-  if (memchr(context.skip_prob, 0, sizeof(context.skip_prob)))
+  if (memchr(skip_prob, 0, sizeof(skip_prob)))
     return false;
-  if (memchr(context.inter_mode_probs, 0, sizeof(context.inter_mode_probs)))
+  if (memchr(inter_mode_probs, 0, sizeof(inter_mode_probs)))
     return false;
-  if (memchr(context.interp_filter_probs, 0,
-             sizeof(context.interp_filter_probs)))
+  if (memchr(interp_filter_probs, 0, sizeof(interp_filter_probs)))
     return false;
-  if (memchr(context.is_inter_prob, 0, sizeof(context.is_inter_prob)))
+  if (memchr(is_inter_prob, 0, sizeof(is_inter_prob)))
     return false;
-  if (memchr(context.comp_mode_prob, 0, sizeof(context.comp_mode_prob)))
+  if (memchr(comp_mode_prob, 0, sizeof(comp_mode_prob)))
     return false;
-  if (memchr(context.single_ref_prob, 0, sizeof(context.single_ref_prob)))
+  if (memchr(single_ref_prob, 0, sizeof(single_ref_prob)))
     return false;
-  if (memchr(context.comp_ref_prob, 0, sizeof(context.comp_ref_prob)))
+  if (memchr(comp_ref_prob, 0, sizeof(comp_ref_prob)))
     return false;
-  if (memchr(context.y_mode_probs, 0, sizeof(context.y_mode_probs)))
+  if (memchr(y_mode_probs, 0, sizeof(y_mode_probs)))
     return false;
-  if (memchr(context.uv_mode_probs, 0, sizeof(context.uv_mode_probs)))
+  if (memchr(uv_mode_probs, 0, sizeof(uv_mode_probs)))
     return false;
-  if (memchr(context.partition_probs, 0, sizeof(context.partition_probs)))
+  if (memchr(partition_probs, 0, sizeof(partition_probs)))
     return false;
-  if (memchr(context.mv_joint_probs, 0, sizeof(context.mv_joint_probs)))
+  if (memchr(mv_joint_probs, 0, sizeof(mv_joint_probs)))
     return false;
-  if (memchr(context.mv_sign_prob, 0, sizeof(context.mv_sign_prob)))
+  if (memchr(mv_sign_prob, 0, sizeof(mv_sign_prob)))
     return false;
-  if (memchr(context.mv_class_probs, 0, sizeof(context.mv_class_probs)))
+  if (memchr(mv_class_probs, 0, sizeof(mv_class_probs)))
     return false;
-  if (memchr(context.mv_class0_bit_prob, 0, sizeof(context.mv_class0_bit_prob)))
+  if (memchr(mv_class0_bit_prob, 0, sizeof(mv_class0_bit_prob)))
     return false;
-  if (memchr(context.mv_bits_prob, 0, sizeof(context.mv_bits_prob)))
+  if (memchr(mv_bits_prob, 0, sizeof(mv_bits_prob)))
     return false;
-  if (memchr(context.mv_class0_fr_probs, 0, sizeof(context.mv_class0_fr_probs)))
+  if (memchr(mv_class0_fr_probs, 0, sizeof(mv_class0_fr_probs)))
     return false;
-  if (memchr(context.mv_fr_probs, 0, sizeof(context.mv_fr_probs)))
+  if (memchr(mv_fr_probs, 0, sizeof(mv_fr_probs)))
     return false;
-  if (memchr(context.mv_class0_hp_prob, 0, sizeof(context.mv_class0_hp_prob)))
+  if (memchr(mv_class0_hp_prob, 0, sizeof(mv_class0_hp_prob)))
     return false;
-  if (memchr(context.mv_hp_prob, 0, sizeof(context.mv_hp_prob)))
+  if (memchr(mv_hp_prob, 0, sizeof(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(frame_context.IsValid());
   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 (!frame_context.IsValid()) {
     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)
+  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);
+}
+
+const Vp9Parser::ReferenceSlot& Vp9Parser::Context::GetRefSlot(
+    size_t ref_type) const {
+  DCHECK_LT(ref_type, arraysize(ref_slots_));
+  return ref_slots_[ref_type];
+}
+
+void Vp9Parser::Context::UpdateRefSlot(
+    size_t ref_type,
+    const Vp9Parser::ReferenceSlot& ref_slot) {
+  DCHECK_LT(ref_type, arraysize(ref_slots_));
+  ref_slots_[ref_type] = ref_slot;
+}
+
 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)
+      DVLOG(3) << "waiting frame_context_idx=" << frame_context_idx
                << " to update";
       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(
+    size_t frame_context_idx) {
+  DCHECK_LT(frame_context_idx, arraysize(context_.frame_context_managers_));
+  auto& frame_context_manager =
+      context_.frame_context_managers_[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 126 matching lines @@
               "quantizer lookup arrays of incorrect size");
 
 static size_t ClampQ(size_t q) {
   return std::min(std::max(static_cast<size_t>(0), q),
                   arraysize(kDcQLookup) - 1);
 }
 
 // 8.6.1 Dequantization functions
 size_t Vp9Parser::GetQIndex(const Vp9QuantizationParams& quant,
                             size_t segid) const {
-  const Vp9SegmentationParams& segmentation = context_.segmentation;
+  const Vp9SegmentationParams& segmentation = context_.segmentation();
 
   if (segmentation.FeatureEnabled(segid,
                                   Vp9SegmentationParams::SEG_LVL_ALT_Q)) {
     int16_t feature_data =
         segmentation.FeatureData(segid, Vp9SegmentationParams::SEG_LVL_ALT_Q);
     size_t q_index = segmentation.abs_or_delta_update
                          ? feature_data
                          : quant.base_q_idx + feature_data;
     return ClampQ(q_index);
   }
 
   return quant.base_q_idx;
 }
 
 // 8.6.1 Dequantization functions
 void Vp9Parser::SetupSegmentationDequant() {
   const Vp9QuantizationParams& quant = curr_frame_header_.quant_params;
-  Vp9SegmentationParams& segmentation = context_.segmentation;
+  Vp9SegmentationParams& segmentation = context_.segmentation_;
 
   DLOG_IF(ERROR, curr_frame_header_.bit_depth > 8)
       << "bit_depth > 8 is not supported "
          "yet, kDcQLookup and kAcQLookup "
          "need extended";
   if (segmentation.enabled) {
     for (size_t i = 0; i < Vp9SegmentationParams::kNumSegments; ++i) {
       const size_t q_index = GetQIndex(quant, i);
       segmentation.y_dequant[i][0] =
           kDcQLookup[ClampQ(q_index + quant.delta_q_y_dc)];
@@ skipping 15 matching lines @@
   }
 }
 
 static int ClampLf(int lf) {
   const int kMaxLoopFilterLevel = 63;
   return std::min(std::max(0, lf), kMaxLoopFilterLevel);
 }
 
 // 8.8.1 Loop filter frame init process
 void Vp9Parser::SetupLoopFilter() {
-  Vp9LoopFilterParams& loop_filter = context_.loop_filter;
+  Vp9LoopFilterParams& loop_filter = context_.loop_filter_;
   if (!loop_filter.level)
     return;
 
   int scale = loop_filter.level < 32 ? 1 : 2;
 
   for (size_t i = 0; i < Vp9SegmentationParams::kNumSegments; ++i) {
     int level = loop_filter.level;
-    Vp9SegmentationParams& segmentation = context_.segmentation;
+    const Vp9SegmentationParams& segmentation = context_.segmentation();
 
     if (segmentation.FeatureEnabled(i, Vp9SegmentationParams::SEG_LVL_ALT_LF)) {
       int feature_data =
           segmentation.FeatureData(i, Vp9SegmentationParams::SEG_LVL_ALT_LF);
       level = ClampLf(segmentation.abs_or_delta_update ? feature_data
                                                        : level + feature_data);
     }
 
     if (!loop_filter.delta_enabled) {
       memset(loop_filter.lvl[i], level, sizeof(loop_filter.lvl[i]));
@@ skipping 12 matching lines @@
         }
       }
     }
   }
 }
 
 void Vp9Parser::UpdateSlots() {
   // 8.10 Reference frame update process
   for (size_t i = 0; i < kVp9NumRefFrames; i++) {
     if (curr_frame_header_.RefreshFlag(i)) {
-      ReferenceSlot& ref = context_.ref_slots[i];
-      ref.initialized = true;
+      ReferenceSlot ref_slot;
+      ref_slot.initialized = true;
 
-      ref.frame_width = curr_frame_header_.frame_width;
-      ref.frame_height = curr_frame_header_.frame_height;
-      ref.subsampling_x = curr_frame_header_.subsampling_x;
-      ref.subsampling_y = curr_frame_header_.subsampling_y;
-      ref.bit_depth = curr_frame_header_.bit_depth;
+      ref_slot.frame_width = curr_frame_header_.frame_width;
+      ref_slot.frame_height = curr_frame_header_.frame_height;
+      ref_slot.subsampling_x = curr_frame_header_.subsampling_x;
+      ref_slot.subsampling_y = curr_frame_header_.subsampling_y;
+      ref_slot.bit_depth = curr_frame_header_.bit_depth;
 
-      ref.profile = curr_frame_header_.profile;
-      ref.color_space = curr_frame_header_.color_space;
+      ref_slot.profile = curr_frame_header_.profile;
+      ref_slot.color_space = curr_frame_header_.color_space;
+      context_.UpdateRefSlot(i, ref_slot);
     }
   }
 }
 
 }  // namespace media