Updating OpenH264 to v1.7.0

modules/video_coding/codecs/test/videoprocessor_integrationtest.cc

 /*
  *  Copyright (c) 2017 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.
  */
 
@@ skipping 157 matching lines @@
   rc_threshold->max_num_frames_to_hit_target = max_num_frames_to_hit_target;
   rc_threshold->num_spatial_resizes = num_spatial_resizes;
   rc_threshold->num_key_frames = num_key_frames;
 }
 
 // Processes all frames in the clip and verifies the result.
 void VideoProcessorIntegrationTest::ProcessFramesAndMaybeVerify(
     const RateProfile& rate_profile,
     const std::vector<RateControlThresholds>* rc_thresholds,
     const QualityThresholds* quality_thresholds,
+    const BitstreamThresholds* bs_thresholds,
     const VisualizationParams* visualization_params) {
   // The Android HW codec needs to be run on a task queue, so we simply always
   // run the test on a task queue.
   rtc::TaskQueue task_queue("VidProc TQ");
   rtc::Event sync_event(false, false);
 
   SetUpAndInitObjects(&task_queue, rate_profile.target_bit_rate[0],
                       rate_profile.input_frame_rate[0], visualization_params);
 
   // Set initial rates.
@@ skipping 50 matching lines @@
         sync_event.Set();
       });
   sync_event.Wait(rtc::Event::kForever);
 
   rate_update_index = 0;
   frame_number = 0;
   ResetRateControlMetrics(rate_update_index, rate_profile);
   while (frame_number < num_frames) {
     UpdateRateControlMetrics(frame_number);
 
+    if (bs_thresholds) {
+      VerifyBitstream(frame_number, bs_thresholds);
+    }
+
     ++frame_number;
 
     if (frame_number ==
         rate_profile.frame_index_rate_update[rate_update_index + 1]) {
       PrintRateControlMetrics(rate_update_index, num_dropped_frames,
                               num_spatial_resizes);
       VerifyRateControlMetrics(rate_update_index, rc_thresholds,
                                num_dropped_frames, num_spatial_resizes);
       ++rate_update_index;
       ResetRateControlMetrics(rate_update_index, rate_profile);
@@ skipping 69 matching lines @@
       break;
     case kVideoCodecVP9:
       codec = cricket::VideoCodec(cricket::kVp9CodecName);
       encoder_.reset(encoder_factory->CreateVideoEncoder(codec));
       decoder_ =
           decoder_factory_->CreateVideoDecoderWithParams(codec, decoder_params);
       break;
     case kVideoCodecH264:
       // TODO(brandtr): Generalize so that we support multiple profiles here.
       codec = cricket::VideoCodec(cricket::kH264CodecName);
+      if (config_.packetization_mode == H264PacketizationMode::NonInterleaved) {
+        codec.SetParam(cricket::kH264FmtpPacketizationMode, "1");
+      } else {
+        codec.SetParam(cricket::kH264FmtpPacketizationMode, "0");

[hbos, 2017/09/25 11:02:35]

nit: RTC_DCHECK_EQ(config_packetization_mode,
H264PacketizationMode::SingleNalUnit);

+      }
       encoder_.reset(encoder_factory->CreateVideoEncoder(codec));
       decoder_ =
           decoder_factory_->CreateVideoDecoderWithParams(codec, decoder_params);
       break;
     default:
       RTC_NOTREACHED();
       break;
   }
 
   if (config_.sw_fallback_encoder) {
@@ skipping 206 matching lines @@
     printf("  Layer encoded bitrate       : %f\n", actual_.kbps_layer[i]);
     printf("  Layer frame size %% mismatch : %d\n",
            actual_.DeltaFrameSizeMismatchPercent(i));
     printf("  Layer bitrate %% mismatch    : %d\n",
            actual_.BitrateMismatchPercent(i, target_.kbps_layer[i]));
     printf("  # processed frames per layer: %d\n", actual_.num_frames_layer[i]);
   }
   printf("\n");
 }
 
+void VideoProcessorIntegrationTest::VerifyBitstream(
+  int frame_number,
+  const BitstreamThresholds *bs_thresholds) {
+    RTC_CHECK_GE(frame_number, 0);
+    const FrameStatistic* frame_stat = stats_.GetFrame(frame_number);
+    EXPECT_LE(frame_stat->max_nalu_length, bs_thresholds->max_nalu_length);
+}
+
 // Temporal layer index corresponding to frame number, for up to 3 layers.
 int VideoProcessorIntegrationTest::TemporalLayerIndexForFrame(
     int frame_number) const {
   int tl_idx = -1;
   switch (NumberOfTemporalLayers(config_.codec_settings)) {
     case 1:
       tl_idx = 0;
       break;
     case 2:
       // temporal layer 0:  0     2     4 ...
@@ skipping 73 matching lines @@
 
   // Update layer per-frame-bandwidth.
   for (int i = 0; i < num_temporal_layers; ++i) {
     target_.framesize_kbits_layer[i] =
         target_.kbps_layer[i] / target_.fps_layer[i];
   }
 }
 
 }  // namespace test
 }  // namespace webrtc