Detect H264 slices of the same frame in VEAUnittest

media/gpu/video_encode_accelerator_unittest.cc

 // Copyright 2013 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 <inttypes.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 586 matching lines @@
  public:
   explicit H264Validator(const FrameFoundCallback& frame_cb)
       : StreamValidator(frame_cb),
         seen_sps_(false),
         seen_pps_(false),
         seen_idr_(false) {}
 
   void ProcessStreamBuffer(const uint8_t* stream, size_t size) override;
 
  private:
+  bool IsNewFrame(const H264NALU& nalu, int sps_id);
+  bool IsNewPrimaryCodedPicture(const H264SliceHeader* slice_hdr,
+                                int sps_id) const;
+
   // Set to true when encoder provides us with the corresponding NALU type.
   bool seen_sps_;
   bool seen_pps_;
   bool seen_idr_;
 
   H264Parser h264_parser_;
+  std::unique_ptr<H264SliceHeader> curr_slice_hdr_;
+  int curr_pic_order_cnt_type_;
 };
 
 void H264Validator::ProcessStreamBuffer(const uint8_t* stream, size_t size) {
   h264_parser_.SetStream(stream, static_cast<off_t>(size));
 
   while (1) {
     H264NALU nalu;
     H264Parser::Result result;
 
     result = h264_parser_.AdvanceToNextNALU(&nalu);
     if (result == H264Parser::kEOStream)
       break;
 
     ASSERT_EQ(H264Parser::kOk, result);
-
     bool keyframe = false;
 
+    int sps_id = 0;
     switch (nalu.nal_unit_type) {
       case H264NALU::kIDRSlice:
         ASSERT_TRUE(seen_sps_);
         ASSERT_TRUE(seen_pps_);
         seen_idr_ = true;
         keyframe = true;
       // fallthrough
       case H264NALU::kNonIDRSlice: {
         ASSERT_TRUE(seen_idr_);
-        seen_sps_ = seen_pps_ = false;
-        if (!frame_cb_.Run(keyframe))
+        if (IsNewFrame(nalu, sps_id) && !frame_cb_.Run(keyframe))
           return;
         break;
       }
 
       case H264NALU::kSPS: {
-        int sps_id;
         ASSERT_EQ(H264Parser::kOk, h264_parser_.ParseSPS(&sps_id));
         seen_sps_ = true;
         break;
       }
 
       case H264NALU::kPPS: {
         ASSERT_TRUE(seen_sps_);
         int pps_id;
         ASSERT_EQ(H264Parser::kOk, h264_parser_.ParsePPS(&pps_id));
         seen_pps_ = true;
         break;
       }
 
       default:
         break;
     }
   }
 }
 
+bool H264Validator::IsNewFrame(const H264NALU& nalu, int sps_id) {
+  std::unique_ptr<H264SliceHeader> slice_hdr(new H264SliceHeader());
+  const bool par_res = h264_parser_.ParseSliceHeader(nalu, slice_hdr.get());
+  if (par_res != H264Parser::kOk) {
+    LOG(ERROR) << "Cannot parse H264 slice header.";
+    return true;
+  }
+
+  const bool is_new_frame = IsNewPrimaryCodedPicture(slice_hdr.get(), sps_id);
+
+  curr_slice_hdr_.reset(slice_hdr.release());
+  if (seen_sps_) {
+    const H264SPS* sps = h264_parser_.GetSPS(sps_id);
+    if (!sps) {
+      LOG(ERROR) << "Cannot parse SPS.";
+      return true;
+    }
+    curr_pic_order_cnt_type_ = sps->pic_order_cnt_type;
+  }
+  return is_new_frame;
+}
+
+// This function follows the checks from H264Decoder::IsNewPrimaryCodedPicture()
+// to identify if the given |slice_hdr| belongs to a new frame.
+bool H264Validator::IsNewPrimaryCodedPicture(const H264SliceHeader* slice_hdr,

[Pawel Osciak, 2016/11/30 02:05:22]

Perhaps we would be able to turn H264Decoder::IsNewPrimaryCodedPicture() into a
static call by passing the previous slice header instead of using curr_pic_ in
there as well, and use it here directly?

[emircan, 2016/12/05 21:24:31]

Done.

+                                             int sps_id) const {
+  if (!curr_slice_hdr_)
+    return true;
+
+  if (slice_hdr->frame_num != curr_slice_hdr_->frame_num ||
+      slice_hdr->pic_parameter_set_id !=
+          curr_slice_hdr_->pic_parameter_set_id ||
+      slice_hdr->nal_ref_idc != curr_slice_hdr_->nal_ref_idc ||
+      slice_hdr->idr_pic_flag != curr_slice_hdr_->idr_pic_flag ||
+      (slice_hdr->idr_pic_flag &&
+       (slice_hdr->idr_pic_id != curr_slice_hdr_->idr_pic_id ||
+        slice_hdr->first_mb_in_slice == 0)))
+    return true;
+
+  const H264SPS* sps = h264_parser_.GetSPS(sps_id);
+  if (!sps)
+    return false;
+
+  if (sps->pic_order_cnt_type == curr_pic_order_cnt_type_) {
+    if (curr_pic_order_cnt_type_ == 0) {
+      if (slice_hdr->pic_order_cnt_lsb != curr_slice_hdr_->pic_order_cnt_lsb ||
+          slice_hdr->delta_pic_order_cnt_bottom !=
+              curr_slice_hdr_->delta_pic_order_cnt_bottom)
+        return true;
+    } else if (curr_pic_order_cnt_type_ == 1) {
+      if (slice_hdr->delta_pic_order_cnt0 !=
+              curr_slice_hdr_->delta_pic_order_cnt0 ||
+          slice_hdr->delta_pic_order_cnt1 !=
+              curr_slice_hdr_->delta_pic_order_cnt1)
+        return true;
+    }
+  }
+
+  return false;
+}
+
 class VP8Validator : public StreamValidator {
  public:
   explicit VP8Validator(const FrameFoundCallback& frame_cb)
       : StreamValidator(frame_cb), seen_keyframe_(false) {}
 
   void ProcessStreamBuffer(const uint8_t* stream, size_t size) override;
 
  private:
   // Have we already got a keyframe in the stream?
   bool seen_keyframe_;
@@ skipping 1418 matching lines @@
                         VideoEncodeAcceleratorTest,
                         ::testing::Values(std::make_tuple(3,
                                                           false,
                                                           0,
                                                           false,
                                                           false,
                                                           false,
                                                           false,
                                                           false,
                                                           false)));
+
+INSTANTIATE_TEST_CASE_P(
+    VerifyTimestamp,
+    VideoEncodeAcceleratorTest,
+    ::testing::Values(
+        std::make_tuple(1, false, 0, false, false, false, false, false, true)));
+
 #if defined(OS_WIN)
 INSTANTIATE_TEST_CASE_P(
     ForceBitrate,
     VideoEncodeAcceleratorTest,
     ::testing::Values(
         std::make_tuple(1, false, 0, true, false, false, false, false, false)));
 #endif  // defined(OS_WIN)
 
 #endif  // defined(OS_CHROMEOS)
 
@@ skipping 85 matching lines @@
 
   media::g_env =
       reinterpret_cast<media::VideoEncodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new media::VideoEncodeAcceleratorTestEnvironment(
                   std::move(test_stream_data), log_path, run_at_fps,
                   needs_encode_latency, verify_all_output)));
 
   return RUN_ALL_TESTS();
 }