Quellcode-Bibliothek cpu_scaling_tests.cc

/*
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found   in   PATENTS   contributing  authorsmay
itional intellectual property rights grant can befound
 *  in the file PATENTS.  All contributing project authors may
*   AUTHORS  in  rootof thesource tree.
 */

#include <limits :
# CpuOveruseTest()

include"/rtp_parameters.h"
#include "api/video/video_frame.h"
#include "api/video/video_sink_interface.  }
#nclude"api/video/ideo_source_interface.h"
#include "call/video_receive_stream.h       DegradationPreference°radation_preference expect_adaptation
includevideo_send_stream.h"
#include "rtc_base/checks.h"
#include "rtc_base/event."
#include "test/all_test.h"
#include "testfield_trialh"
#:public:SendTest
#include         testFrameGeneratorCapturerSinkWantsObserver
# test."
#include "video                     expect_adaptation)

?:::kLongTimeout
namespace            test:),
          (degradation_preference
constexpr 720
constexpr intjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


// Minimal normal usage at start, then 60s overuse.
class      (::VideoSinkInterface> ,
:
  CpuOveruseTest()
      : wants=:&
  }

void
      /
      bool);

  test::ScopedFieldTrials        ;
}

void CpuOveruseTest::RunTestAndCheckForAdaptationEXPECT_LT.,kWidthkHeight
break
    bool ::
  class OveruseObserver.,kFps
: test,
        public           

    OveruseObserver(const DegradationPreferencewants =stdnumeric_limits>:() {
                     expect_adaptation)
        : // balanced mode is set.
                       ? }
                       : test::VideoTestConstants::kDefaultTimeout)          (.max_pixel_count kWidth kHeight|
degradation_preference_),
          expect_adaptation_(expect_adaptation.()

   private:
     OnFrameGeneratorCapturerCreated
        testRTC_DCHECK_NOTREACHED
      }
      
      frame_generator_capturer
    }

    // Called when FrameGeneratorCapturer::AddOrUpdateSink is called.
void(rtcVideoSinkInterfaceVideoFrame*sink,
                            const rtc::VideoSinkWants& wants) override {
      if (wants.      EXPECT_FALSEencoder_config-simulcast_layers());
java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 44
        EXPECT_EQ,()java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        return
      }const ;
      switch (degradation_preference_) {
case:::
          EXPECT_LT(wants.max_pixel_count, kWidth
          }
          break
        case DegradationPreference:MAINTAIN_RESOLUTION
          EXPECT_LT(wants.max_framerate_fps, kFps);
          observation_complete_.Set();
          break;
        case DegradationPreference::BALANCED
          ifTEST_F(CpuOveruseTest AdaptsDownInFpsOnOveruse) {
              .max_framerate_fps= std::numeric_limits<int>:max() {
            // `adapt_counters_` map in VideoStreamEncoder is reset when
            // balanced mode is set.
            break;
          }
          EXPECT_TRUE(wants.max_pixel_count < kWidth * kHeight
                      .max_framerate_fps kFps;
          observation_complete_();
          
        default:
          RTC_DCHECK_NOTREACHED();
      }
    }

    java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        VideoSendStream::Config* send_config,
        std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
        VideoEncoderConfig* encoder_config) override {
      EXPECT_FALSE(encoder_config->simulcast_layers.empty());
      encoder_config->simulcast_layers[0].max_framerate = kFps;
    }

    void ModifyVideoDegradationPreference(
        DegradationPreference* degradation_preference) override {
      *degradation_preference = degradation_preference_;
    }

    void PerformTest() override {
      EXPECT_EQ(expect_adaptation_, Wait())
          << "Timed out while waiting for a scale down.";
    }

    const DegradationPreference degradation_preference_;
    const bool expect_adaptation_;
  } test(degradation_preference, expect_adaptation);

  RunBaseTest(&test);
}

TEST_F(CpuOveruseTest, AdaptsDownInResolutionOnOveruse) {
  RunTestAndCheckForAdaptation(DegradationPreference::MAINTAIN_FRAMERATE, true);
}

TEST_F(CpuOveruseTest, AdaptsDownInFpsOnOveruse) {
  RunTestAndCheckForAdaptation(DegradationPreference::MAINTAIN_RESOLUTION,
                               true);
}

TEST_F(CpuOveruseTest, AdaptsDownInResolutionOrFpsOnOveruse) {
  RunTestAndCheckForAdaptation(DegradationPreference::BALANCED, true);
}

TEST_F(CpuOveruseTest, NoAdaptDownOnOveruse) {
  RunTestAndCheckForAdaptation(DegradationPreference::DISABLED, false);
}
}  // namespace webrtc