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);

[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());
   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