Adding test for SingleNalUnit mode

modules/video_coding/codecs/test/videoprocessor.cc

Index: modules/video_coding/codecs/test/videoprocessor.cc
diff --git a/modules/video_coding/codecs/test/videoprocessor.cc b/modules/video_coding/codecs/test/videoprocessor.cc
index af5b4b35b5e75465823f89dbf0aaa5416568db21..9daecbb43902cee550c586bca7877e466588e106 100644
--- a/modules/video_coding/codecs/test/videoprocessor.cc
+++ b/modules/video_coding/codecs/test/videoprocessor.cc
@@ -12,6 +12,7 @@
 
 #include <string.h>
 
+#include <algorithm>
 #include <limits>
 #include <memory>
 #include <utility>
@@ -19,6 +20,7 @@
 
 #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"
@@ -108,6 +110,22 @@ void VerifyQpParser(const EncodedImage& encoded_frame,
   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);

[hbos, 2017/09/27 15:56:42]

Should we return empty optional if nalu_indices is empty or 0?

[ssilkin, 2017/09/28 09:53:09]

Added RTC_CHECK for empty nalu_indices. It is expected that output buffer
contains at least 1 NALU.

[hbos, 2017/09/28 12:08:34]

Is it safe to assume the encoded image is "correct" at this point? Imagine me
trying to crash your endpoint by sending broken frames.

[hbos, 2017/09/28 12:10:45]

Or is this only on frames we've encoded?

[brandtr, 2017/09/28 13:39:26]

This is just test code, so I think it's OK to be liberal about using CHECKs
here.

The reason that we have used CHECKs (instead of DCHECKs) in other parts of this
class is that we generally want to run it in Release mode, for performance
reasons. So to save on testing 
 iterations (the Chromium test runner is a bit slow getting started sometimes),
we have used CHECKs...

+
+  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());
@@ -351,6 +369,8 @@ void VideoProcessor::FrameEncoded(webrtc::VideoCodecType codec,
       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) {