Adding test for SingleNalUnit mode

modules/video_coding/codecs/test/videoprocessor.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "modules/video_coding/codecs/test/videoprocessor.h"
 
 #include <string.h>
 
+#include <algorithm>
 #include <limits>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "api/video/i420_buffer.h"
 #include "common_types.h"  // NOLINT(build/include)
+#include "common_video/h264/h264_common.h"
 #include "modules/video_coding/codecs/vp8/simulcast_rate_allocator.h"
 #include "modules/video_coding/include/video_codec_initializer.h"
 #include "modules/video_coding/utility/default_video_bitrate_allocator.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/timeutils.h"
 #include "system_wrappers/include/cpu_info.h"
 #include "test/gtest.h"
 
 namespace webrtc {
@@ skipping 69 matching lines @@
   if (config.codec_settings.codecType == kVideoCodecVP8) {
     ASSERT_TRUE(vp8::GetQp(encoded_frame._buffer, encoded_frame._length, &qp));
   } else if (config.codec_settings.codecType == kVideoCodecVP9) {
     ASSERT_TRUE(vp9::GetQp(encoded_frame._buffer, encoded_frame._length, &qp));
   } else {
     return;
   }
   EXPECT_EQ(encoded_frame.qp_, qp) << "Encoder QP != parsed bitstream QP.";
 }
 
+rtc::Optional<size_t> GetMaxNaluLength(const EncodedImage& encoded_frame,
+                                       const TestConfig& config) {
+  if (config.codec_settings.codecType != kVideoCodecH264)
+    return rtc::Optional<size_t>();
+
+  std::vector<webrtc::H264::NaluIndex> nalu_indices =
+      webrtc::H264::FindNaluIndices(encoded_frame._buffer,
+                                    encoded_frame._length);
+
+  RTC_CHECK(!nalu_indices.empty());
+
+  size_t max_length = 0;
+  for (const webrtc::H264::NaluIndex& index : nalu_indices)
+    max_length = std::max(max_length, index.payload_size);
+
+  return rtc::Optional<size_t>(max_length);
+}
+
 int GetElapsedTimeMicroseconds(int64_t start_ns, int64_t stop_ns) {
   int64_t diff_us = (stop_ns - start_ns) / rtc::kNumNanosecsPerMicrosec;
   RTC_DCHECK_GE(diff_us, std::numeric_limits<int>::min());
   RTC_DCHECK_LE(diff_us, std::numeric_limits<int>::max());
   return static_cast<int>(diff_us);
 }
 
 }  // namespace
 
 const char* ExcludeFrameTypesToStr(ExcludeFrameTypes e) {
@@ skipping 223 matching lines @@
   frame_stat->encoding_successful = true;
   frame_stat->encoded_frame_size_bytes = encoded_image._length;
   frame_stat->frame_type = encoded_image._frameType;
   frame_stat->qp = encoded_image.qp_;
   frame_stat->bitrate_kbps = static_cast<int>(
       encoded_image._length * config_.codec_settings.maxFramerate * 8 / 1000);
   frame_stat->total_packets =
       encoded_image._length / config_.networking_config.packet_size_in_bytes +
       1;
 
+  frame_stat->max_nalu_length = GetMaxNaluLength(encoded_image, config_);
+
   // Simulate packet loss.
   bool exclude_this_frame = false;
   if (encoded_image._frameType == kVideoFrameKey) {
     // Only keyframes can be excluded.
     switch (config_.exclude_frame_types) {
       case kExcludeOnlyFirstKeyFrame:
         if (!first_key_frame_has_been_excluded_) {
           first_key_frame_has_been_excluded_ = true;
           exclude_this_frame = true;
         }
@@ skipping 113 matching lines @@
   if (decoded_frame_writer_) {
     RTC_DCHECK_EQ(extracted_length, decoded_frame_writer_->FrameLength());
     RTC_CHECK(decoded_frame_writer_->WriteFrame(extracted_buffer.data()));
   }
 
   last_decoded_frame_buffer_ = std::move(extracted_buffer);
 }
 
 }  // namespace test
 }  // namespace webrtc