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

media/filters/vp9_uncompressed_header_parser.cc

 // Copyright 2016 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 "media/filters/vp9_uncompressed_header_parser.h"
 
 #include "base/logging.h"
 
 namespace media {
 
@@ skipping 693 matching lines @@
     fhdr->render_height = fhdr->frame_height;
   }
 }
 
 // 6.2.5 Frame size with refs syntax
 bool Vp9UncompressedHeaderParser::ReadFrameSizeFromRefs(Vp9FrameHeader* fhdr) {
   bool found_ref = false;
   for (const auto& idx : fhdr->ref_frame_idx) {
     found_ref = reader_.ReadBool();
     if (found_ref) {
-      const Vp9Parser::ReferenceSlot& ref = context_->ref_slots[idx];
+      const Vp9Parser::ReferenceSlot& ref = context_->GetRefSlot(idx);
       DCHECK(ref.initialized);
       fhdr->frame_width = ref.frame_width;
       fhdr->frame_height = ref.frame_height;
 
       const unsigned kMaxDimension = 1u << 16;
       DCHECK_LE(fhdr->frame_width, kMaxDimension);
       DCHECK_LE(fhdr->frame_height, kMaxDimension);
       break;
     }
   }
 
   if (!found_ref)
     ReadFrameSize(fhdr);
 
   // 7.2.5 Frame size with refs semantics
   bool has_valid_ref_frame = false;
   for (const auto& idx : fhdr->ref_frame_idx) {
-    const Vp9Parser::ReferenceSlot& ref = context_->ref_slots[idx];
+    const Vp9Parser::ReferenceSlot& ref = context_->GetRefSlot(idx);
     if (2 * fhdr->frame_width >= ref.frame_width &&
         2 * fhdr->frame_height >= ref.frame_height &&
         fhdr->frame_width <= 16 * ref.frame_width &&
         fhdr->frame_height <= 16 * ref.frame_height) {
       has_valid_ref_frame = true;
       break;
     }
   }
   if (!has_valid_ref_frame) {
     DVLOG(1) << "There should be at least one reference frame meeting "
@@ skipping 12 matching lines @@
 
   // The mapping table for next two bits.
   const Vp9InterpolationFilter table[] = {
       Vp9InterpolationFilter::EIGHTTAP_SMOOTH, Vp9InterpolationFilter::EIGHTTAP,
       Vp9InterpolationFilter::EIGHTTAP_SHARP, Vp9InterpolationFilter::BILINEAR,
   };
   return table[reader_.ReadLiteral(2)];
 }
 
 void Vp9UncompressedHeaderParser::SetupPastIndependence(Vp9FrameHeader* fhdr) {
-  memset(&context_->segmentation, 0, sizeof(context_->segmentation));
+  memset(&context_->segmentation_, 0, sizeof(context_->segmentation_));
   ResetLoopfilter();
   fhdr->frame_context = kVp9DefaultFrameContext;
-  DCHECK(Vp9FrameContextManager::IsValidFrameContext(fhdr->frame_context));
+  DCHECK(fhdr->frame_context.IsValid());
 }
 
 // 6.2.8 Loop filter params syntax
 void Vp9UncompressedHeaderParser::ReadLoopFilterParams() {
-  Vp9LoopFilterParams& loop_filter = context_->loop_filter;
+  Vp9LoopFilterParams& loop_filter = context_->loop_filter_;
 
   loop_filter.level = reader_.ReadLiteral(6);
   loop_filter.sharpness = reader_.ReadLiteral(3);
   loop_filter.delta_update = false;
 
   loop_filter.delta_enabled = reader_.ReadBool();
   if (loop_filter.delta_enabled) {
     loop_filter.delta_update = reader_.ReadBool();
     if (loop_filter.delta_update) {
       for (size_t i = 0; i < Vp9RefType::VP9_FRAME_MAX; i++) {
@@ skipping 23 matching lines @@
 
 // 6.2.10 Delta quantizer syntax
 int8_t Vp9UncompressedHeaderParser::ReadDeltaQ() {
   if (reader_.ReadBool())
     return reader_.ReadSignedLiteral(4);
   return 0;
 }
 
 // 6.2.11 Segmentation params syntax
 bool Vp9UncompressedHeaderParser::ReadSegmentationParams() {
-  Vp9SegmentationParams& segmentation = context_->segmentation;
+  Vp9SegmentationParams& segmentation = context_->segmentation_;
   segmentation.update_map = false;
   segmentation.update_data = false;
 
   segmentation.enabled = reader_.ReadBool();
   if (!segmentation.enabled)
     return true;
 
   segmentation.update_map = reader_.ReadBool();
   if (segmentation.update_map) {
     for (auto& tree_prob : segmentation.tree_probs) {
@@ skipping 61 matching lines @@
   // 7.2.11 Tile info semantics
   if (fhdr->tile_cols_log2 > 6) {
     DVLOG(1) << "tile_cols_log2 should be <= 6";
     return false;
   }
 
   return true;
 }
 
 void Vp9UncompressedHeaderParser::ResetLoopfilter() {
-  Vp9LoopFilterParams& loop_filter = context_->loop_filter;
+  Vp9LoopFilterParams& loop_filter = context_->loop_filter_;
 
   loop_filter.delta_enabled = true;
   loop_filter.delta_update = true;
 
   loop_filter.ref_deltas[VP9_FRAME_INTRA] = 1;
   loop_filter.ref_deltas[VP9_FRAME_LAST] = 0;
   loop_filter.ref_deltas[VP9_FRAME_GOLDEN] = -1;
   loop_filter.ref_deltas[VP9_FRAME_ALTREF] = -1;
 
   memset(loop_filter.mode_deltas, 0, sizeof(loop_filter.mode_deltas));
@@ skipping 84 matching lines @@
                         Vp9RefType::VP9_FRAME_LAST + kVp9NumRefsPerFrame,
                     "ref_frame_sign_bias is not big enough");
       for (size_t i = 0; i < kVp9NumRefsPerFrame; i++) {
         fhdr->ref_frame_idx[i] = reader_.ReadLiteral(kVp9NumRefFramesLog2);
         fhdr->ref_frame_sign_bias[Vp9RefType::VP9_FRAME_LAST + i] =
             reader_.ReadBool();
 
         // 8.2 Frame order constraints
         // ref_frame_idx[i] refers to an earlier decoded frame.
         const Vp9Parser::ReferenceSlot& ref =
-            context_->ref_slots[fhdr->ref_frame_idx[i]];
+            context_->GetRefSlot(fhdr->ref_frame_idx[i]);
         if (!ref.initialized) {
           DVLOG(1) << "ref_frame_idx[" << i
                    << "]=" << static_cast<int>(fhdr->ref_frame_idx[i])
                    << " refers to unused frame";
           return false;
         }
 
         // 7.2 Uncompressed header semantics
         // the selected reference frames match the current frame in bit depth,
         // profile, chroma subsampling, and color space.
@@ skipping 34 matching lines @@
   }
 
   if (fhdr->error_resilient_mode) {
     fhdr->refresh_frame_context = false;
     fhdr->frame_parallel_decoding_mode = true;
   } else {
     fhdr->refresh_frame_context = reader_.ReadBool();
     fhdr->frame_parallel_decoding_mode = reader_.ReadBool();
   }
 
-  static_assert(
-      arraysize(context_->frame_context_managers) == (1 << 2),
-      "bits of frame_context_idx doesn't match size of frame_context_managers");
   fhdr->frame_context_idx_to_save_probs = fhdr->frame_context_idx =
-      reader_.ReadLiteral(2);
+      reader_.ReadLiteral(kVp9NumFrameContextsLog2);
 
   if (fhdr->IsIntra()) {
     SetupPastIndependence(fhdr);
     if (fhdr->IsKeyframe() || fhdr->error_resilient_mode ||
         fhdr->reset_frame_context == 3) {
-      for (auto& frame_context_manage : context_->frame_context_managers)
-        frame_context_manage.Update(fhdr->frame_context);
+      for (size_t i = 0; i < kVp9NumFrameContexts; ++i)
+        context_->UpdateFrameContext(i, fhdr->frame_context);
     } else if (fhdr->reset_frame_context == 2) {
-      context_->frame_context_managers[fhdr->frame_context_idx].Update(
-          fhdr->frame_context);
+      context_->UpdateFrameContext(fhdr->frame_context_idx,
+                                   fhdr->frame_context);
     }
     fhdr->frame_context_idx = 0;
   }
 
   ReadLoopFilterParams();
   ReadQuantizationParams(&fhdr->quant_params);
   if (!ReadSegmentationParams())
     return false;
 
   if (!ReadTileInfo(fhdr))
@@ skipping 12 matching lines @@
   if (!reader_.IsValid()) {
     DVLOG(1) << "parser reads beyond the end of buffer";
     return false;
   }
   fhdr->uncompressed_header_size = reader_.GetBytesRead();
 
   return true;
 }
 
 }  // namespace media