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 726 matching lines @@
       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));
   ResetLoopfilter();
   fhdr->frame_context = kVp9DefaultFrameContext;
-  DCHECK(Vp9FrameContextManager::IsValidFrameContext(fhdr->frame_context));
+  DCHECK(Vp9FrameContext::IsValid(fhdr->frame_context));
 }
 
 // 6.2.8 Loop filter params syntax
 void Vp9UncompressedHeaderParser::ReadLoopFilterParams() {
   Vp9LoopFilterParams& loop_filter = context_->loop_filter;
 
   loop_filter.level = reader_.ReadLiteral(6);
   loop_filter.sharpness = reader_.ReadLiteral(3);
   loop_filter.delta_update = false;
 
@@ skipping 270 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