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

media/filters/vp9_parser_unittest.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.
 
 // For each sample vp9 test video, $filename, there is a file of golden value
 // of frame entropy, named $filename.context. These values are dumped from
 // libvpx.
 //
 // The syntax of these context dump is described as follows.  For every
 // frame, there are corresponding data in context file,
@@ skipping 51 matching lines @@
     return should_update != 0;
   }
 
   void ReadContext(Vp9FrameContext* frame_context) {
     ASSERT_EQ(
         static_cast<int>(sizeof(*frame_context)),
         context_file_.ReadAtCurrentPos(reinterpret_cast<char*>(frame_context),
                                        sizeof(*frame_context)));
   }
 
-  Vp9Parser::Result ParseNextFrame(
-      struct Vp9FrameHeader* frame_hdr,
-      Vp9FrameContextManager::ContextRefreshCallback* context_refresh_cb);
+  Vp9Parser::Result ParseNextFrame(struct Vp9FrameHeader* frame_hdr);
 
   const Vp9SegmentationParams& GetSegmentation() const {
-    return vp9_parser_->GetSegmentation();
+    return vp9_parser_->context().segmentation();
   }
 
   const Vp9LoopFilterParams& GetLoopFilter() const {
-    return vp9_parser_->GetLoopFilter();
+    return vp9_parser_->context().loop_filter();
+  }
+
+  Vp9Parser::ContextRefreshCallback GetContextRefreshCb(
+      const Vp9FrameHeader& frame_hdr) const {
+    return vp9_parser_->GetContextRefreshCb(frame_hdr.frame_context_idx);
   }
 
   IvfParser ivf_parser_;
   std::unique_ptr<base::MemoryMappedFile> stream_;
 
   std::unique_ptr<Vp9Parser> vp9_parser_;
   base::File context_file_;
 };
 
-Vp9Parser::Result Vp9ParserTest::ParseNextFrame(
-    Vp9FrameHeader* fhdr,
-    Vp9FrameContextManager::ContextRefreshCallback* context_refresh_cb) {
+Vp9Parser::Result Vp9ParserTest::ParseNextFrame(Vp9FrameHeader* fhdr) {
   while (1) {
-    Vp9Parser::Result res =
-        vp9_parser_->ParseNextFrame(fhdr, context_refresh_cb);
+    Vp9Parser::Result res = vp9_parser_->ParseNextFrame(fhdr);
     if (res == Vp9Parser::kEOStream) {
       IvfFrameHeader ivf_frame_header;
       const uint8_t* ivf_payload;
 
       if (!ivf_parser_.ParseNextFrame(&ivf_frame_header, &ivf_payload))
         return Vp9Parser::kEOStream;
 
       vp9_parser_->SetStream(ivf_payload, ivf_frame_header.frame_size);
       continue;
     }
 
     return res;
   }
 }
 
 TEST_F(Vp9ParserTest, StreamFileParsingWithoutCompressedHeader) {
   Initialize("test-25fps.vp9", false);
 
   // Number of frames in the test stream to be parsed.
   const int num_expected_frames = 269;
   int num_parsed_frames = 0;
 
   // Allow to parse twice as many frames in order to detect any extra frames
   // parsed.
   while (num_parsed_frames < num_expected_frames * 2) {
     Vp9FrameHeader fhdr;
-    if (ParseNextFrame(&fhdr, nullptr) != Vp9Parser::kOk)
+    if (ParseNextFrame(&fhdr) != Vp9Parser::kOk)
       break;
 
     ++num_parsed_frames;
   }
 
   DVLOG(1) << "Number of successfully parsed frames before EOS: "
            << num_parsed_frames;
 
   EXPECT_EQ(num_expected_frames, num_parsed_frames);
 }
 
 TEST_F(Vp9ParserTest, StreamFileParsingWithCompressedHeader) {
   Initialize("test-25fps.vp9", true);
 
   // Number of frames in the test stream to be parsed.
   const int num_expected_frames = 269;
   int num_parsed_frames = 0;
 
   // Allow to parse double frames in order to detect extra frames parsed.
   while (num_parsed_frames < num_expected_frames * 2) {
     Vp9FrameHeader fhdr;
-    Vp9FrameContextManager::ContextRefreshCallback context_refresh_cb;
-    if (ParseNextFrame(&fhdr, &context_refresh_cb) != Vp9Parser::kOk)
+    if (ParseNextFrame(&fhdr) != Vp9Parser::kOk)
       break;
 
     Vp9FrameContext frame_context;
     ReadContext(&frame_context);
     EXPECT_TRUE(memcmp(&frame_context, &fhdr.initial_frame_context,
                        sizeof(frame_context)) == 0);
     ReadContext(&frame_context);
     EXPECT_TRUE(memcmp(&frame_context, &fhdr.frame_context,
                        sizeof(frame_context)) == 0);
 
     // test-25fps.vp9 doesn't need frame update from driver.
+    Vp9Parser::ContextRefreshCallback context_refresh_cb =

[kcwu, 2016/08/17 04:06:09]

Since we don't care the detail type here, use "auto" instead?

[Pawel Osciak, 2016/08/19 08:22:44]

Done.

+        GetContextRefreshCb(fhdr);
     EXPECT_TRUE(context_refresh_cb.is_null());
     ASSERT_FALSE(ReadShouldContextUpdate());
 
     ++num_parsed_frames;
   }
 
   DVLOG(1) << "Number of successfully parsed frames before EOS: "
            << num_parsed_frames;
 
   EXPECT_EQ(num_expected_frames, num_parsed_frames);
 }
 
 TEST_F(Vp9ParserTest, StreamFileParsingWithContextUpdate) {
   Initialize("bear-vp9.ivf", true);
 
   // Number of frames in the test stream to be parsed.
   const int num_expected_frames = 82;
   int num_parsed_frames = 0;
 
   // Allow to parse double frames in order to detect extra frames parsed.
   while (num_parsed_frames < num_expected_frames * 2) {
     Vp9FrameHeader fhdr;
-    Vp9FrameContextManager::ContextRefreshCallback context_refresh_cb;
-    if (ParseNextFrame(&fhdr, &context_refresh_cb) != Vp9Parser::kOk)
+    if (ParseNextFrame(&fhdr) != Vp9Parser::kOk)
       break;
 
     Vp9FrameContext frame_context;
     ReadContext(&frame_context);
     EXPECT_TRUE(memcmp(&frame_context, &fhdr.initial_frame_context,
                        sizeof(frame_context)) == 0);
     ReadContext(&frame_context);
     EXPECT_TRUE(memcmp(&frame_context, &fhdr.frame_context,
                        sizeof(frame_context)) == 0);
 
     bool should_update = ReadShouldContextUpdate();
+    Vp9Parser::ContextRefreshCallback context_refresh_cb =
+        GetContextRefreshCb(fhdr);
     if (context_refresh_cb.is_null()) {
       EXPECT_FALSE(should_update);
     } else {
       EXPECT_TRUE(should_update);
       ReadContext(&frame_context);
       context_refresh_cb.Run(frame_context);
     }
 
     ++num_parsed_frames;
   }
 
   DVLOG(1) << "Number of successfully parsed frames before EOS: "
            << num_parsed_frames;
 
   EXPECT_EQ(num_expected_frames, num_parsed_frames);
 }
 
 TEST_F(Vp9ParserTest, AwaitingContextUpdate) {
   Initialize("bear-vp9.ivf", true);
 
   Vp9FrameHeader fhdr;
-  Vp9FrameContextManager::ContextRefreshCallback context_refresh_cb;
-  ASSERT_EQ(Vp9Parser::kOk, ParseNextFrame(&fhdr, &context_refresh_cb));
-  EXPECT_FALSE(context_refresh_cb.is_null());
+  ASSERT_EQ(Vp9Parser::kOk, ParseNextFrame(&fhdr));
 
   Vp9FrameContext frame_context;
   ReadContext(&frame_context);
   ReadContext(&frame_context);
   bool should_update = ReadShouldContextUpdate();
   ASSERT_TRUE(should_update);
   ReadContext(&frame_context);
 
   // Not update yet. Should return kAwaitingRefresh.
-  Vp9FrameContextManager::ContextRefreshCallback unused_cb;
-  EXPECT_EQ(Vp9Parser::kAwaitingRefresh, ParseNextFrame(&fhdr, &unused_cb));
-  EXPECT_EQ(Vp9Parser::kAwaitingRefresh, ParseNextFrame(&fhdr, &unused_cb));
+  EXPECT_EQ(Vp9Parser::kAwaitingRefresh, ParseNextFrame(&fhdr));
+  EXPECT_EQ(Vp9Parser::kAwaitingRefresh, ParseNextFrame(&fhdr));
 
   // After update, parse should be ok.
+  Vp9Parser::ContextRefreshCallback context_refresh_cb =
+      GetContextRefreshCb(fhdr);
+  EXPECT_FALSE(context_refresh_cb.is_null());
   context_refresh_cb.Run(frame_context);
-  EXPECT_EQ(Vp9Parser::kOk, ParseNextFrame(&fhdr, &unused_cb));
+  EXPECT_EQ(Vp9Parser::kOk, ParseNextFrame(&fhdr));
 
   // Make sure it parsed the 2nd frame.
   EXPECT_EQ(9u, fhdr.header_size_in_bytes);
 }
 
 TEST_F(Vp9ParserTest, VerifyFirstFrame) {
   Initialize("test-25fps.vp9", false);
   Vp9FrameHeader fhdr;
 
-  ASSERT_EQ(Vp9Parser::kOk, ParseNextFrame(&fhdr, nullptr));
+  ASSERT_EQ(Vp9Parser::kOk, ParseNextFrame(&fhdr));
 
   EXPECT_EQ(0, fhdr.profile);
   EXPECT_FALSE(fhdr.show_existing_frame);
   EXPECT_EQ(Vp9FrameHeader::KEYFRAME, fhdr.frame_type);
   EXPECT_TRUE(fhdr.show_frame);
   EXPECT_FALSE(fhdr.error_resilient_mode);
 
   EXPECT_EQ(8, fhdr.bit_depth);
   EXPECT_EQ(Vp9ColorSpace::UNKNOWN, fhdr.color_space);
   EXPECT_FALSE(fhdr.color_range);
@@ skipping 35 matching lines @@
   EXPECT_EQ(120u, fhdr.header_size_in_bytes);
   EXPECT_EQ(18u, fhdr.uncompressed_header_size);
 }
 
 TEST_F(Vp9ParserTest, VerifyInterFrame) {
   Initialize("test-25fps.vp9", false);
   Vp9FrameHeader fhdr;
 
   // To verify the second frame.
   for (int i = 0; i < 2; i++)
-    ASSERT_EQ(Vp9Parser::kOk, ParseNextFrame(&fhdr, nullptr));
+    ASSERT_EQ(Vp9Parser::kOk, ParseNextFrame(&fhdr));
 
   EXPECT_EQ(Vp9FrameHeader::INTERFRAME, fhdr.frame_type);
   EXPECT_FALSE(fhdr.show_frame);
   EXPECT_FALSE(fhdr.intra_only);
   EXPECT_FALSE(fhdr.reset_frame_context);
   EXPECT_TRUE(fhdr.RefreshFlag(2));
   EXPECT_EQ(0, fhdr.ref_frame_idx[0]);
   EXPECT_EQ(1, fhdr.ref_frame_idx[1]);
   EXPECT_EQ(2, fhdr.ref_frame_idx[2]);
   EXPECT_TRUE(fhdr.allow_high_precision_mv);
   EXPECT_EQ(Vp9InterpolationFilter::EIGHTTAP, fhdr.interpolation_filter);
 
   EXPECT_EQ(48u, fhdr.header_size_in_bytes);
   EXPECT_EQ(11u, fhdr.uncompressed_header_size);
 }
 
 }  // namespace media