webrtc/video/video_send_stream_tests.cc - Issue 2351633002: Let ViEEncoder handle resolution changes.

Unified Diff: webrtc/video/video_send_stream_tests.cc

Issue 2351633002: Let ViEEncoder handle resolution changes. (Closed)

Patch Set: Fix build on Win Created 4 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: webrtc/video/video_send_stream_tests.cc

diff --git a/webrtc/video/video_send_stream_tests.cc b/webrtc/video/video_send_stream_tests.cc

index a36be32d32834679aa9c12bb58327a6c4b8dae02..e7e753507204163dd7d2e305fb0d8e1de539794b 100644

--- a/webrtc/video/video_send_stream_tests.cc

+++ b/webrtc/video/video_send_stream_tests.cc

@@ -37,6 +37,7 @@

#include "webrtc/test/frame_utils.h"

#include "webrtc/test/null_transport.h"

#include "webrtc/test/testsupport/perf_test.h"

#include "webrtc/video/send_statistics_proxy.h"

#include "webrtc/video_frame.h"

#include "webrtc/video_send_stream.h"

@@ -908,16 +909,18 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {

VideoSendStream::Config* send_config,

std::vector<VideoReceiveStream::Config>* receive_configs,

VideoEncoderConfig* encoder_config) override {

+ RTC_DCHECK_EQ(1u, encoder_config->number_of_streams);

transport_adapter_.reset(

new internal::TransportAdapter(send_config->send_transport));

transport_adapter_->Enable();

send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;

send_config->pre_encode_callback = this;

send_config->suspend_below_min_bitrate = true;

- int min_bitrate_bps = encoder_config->streams[0].min_bitrate_bps;

+ int min_bitrate_bps =

+ test::DefaultVideoStreamFactory::kDefaultMinBitratePerStream[0];

set_low_remb_bps(min_bitrate_bps - 10000);

int threshold_window = std::max(min_bitrate_bps / 10, 20000);

- ASSERT_GT(encoder_config->streams[0].max_bitrate_bps,

+ ASSERT_GT(encoder_config->max_bitrate_bps,

min_bitrate_bps + threshold_window + 5000);

set_high_remb_bps(min_bitrate_bps + threshold_window + 5000);

}

@@ -1206,7 +1209,7 @@ class MaxPaddingSetTest : public test::SendTest {

VideoSendStream::Config* send_config,

std::vector<VideoReceiveStream::Config>* receive_configs,

VideoEncoderConfig* encoder_config) override {

- RTC_DCHECK_EQ(1u, encoder_config->streams.size());

+ RTC_DCHECK_EQ(1u, encoder_config->number_of_streams);

if (running_without_padding_) {

encoder_config->min_transmit_bitrate_bps = 0;

encoder_config->content_type =

@@ -1274,6 +1277,73 @@ TEST_F(VideoSendStreamTest, RespectsMinTransmitBitrateAfterContentSwitch) {

RunBaseTest(&test);

}

+// This test verifies that new frame sizes reconfigures encoders even though not

+// (yet) sending. The purpose of this is to permit encoding as quickly as

+// possible once we start sending. Likely the frames being input are from the

+// same source that will be sent later, which just means that we're ready

+// earlier.

+TEST_F(VideoSendStreamTest,

+ EncoderReconfigureOnResolutionChangeWhenNotSending) {

+ class EncoderObserver : public test::FakeEncoder {

+ public:

+ EncoderObserver()

+ : FakeEncoder(Clock::GetRealTimeClock()),

+ expect_resolution_set_(false, false),

+ expected_width_(0),

+ expected_height_(0) {}

+ void WaitForResolution(int width, int height) {

+ {

+ rtc::CritScope lock(&crit_);

+ expected_width_ = width;

+ expected_height_ = height;

+ }

+ EXPECT_TRUE(

+ expect_resolution_set_.Wait(VideoSendStreamTest::kDefaultTimeoutMs));

sprang_webrtc 2016/09/28 15:51:43 Technically, you should verify that you actually w

perkj_webrtc 2016/09/29 15:05:17 rewritten.

+ }

+ private:

+ int32_t InitEncode(const VideoCodec* config,

+ int32_t number_of_cores,

+ size_t max_payload_size) override {

+ rtc::CritScope lock(&crit_);

+ if (expected_width_ == config->width &&

+ expected_height_ == config->height)

+ expect_resolution_set_.Set();

sprang_webrtc 2016/09/28 15:51:43 nit: {}

perkj_webrtc 2016/09/29 15:05:17 rewritten

+ return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);

+ }

+ int32_t Encode(const VideoFrame& input_image,

+ const CodecSpecificInfo* codec_specific_info,

+ const std::vector<FrameType>* frame_types) override {

+ ADD_FAILURE()

+ << "Unexpected Encode call since the send stream is not started";

+ return 0;

+ }

+ rtc::CriticalSection crit_;

+ rtc::Event expect_resolution_set_;

+ int expected_width_ GUARDED_BY(&crit_);

+ int expected_height_ GUARDED_BY(&crit_);

+ };

+ CreateSenderCall(Call::Config());

+ test::NullTransport transport;

+ CreateSendConfig(1, 0, &transport);

+ EncoderObserver encoder;

+ video_send_config_.encoder_settings.encoder = &encoder;

+ CreateVideoStreams();

+ CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,

+ kDefaultHeight);

+ frame_generator_capturer_->Start();

+ encoder.WaitForResolution(kDefaultWidth, kDefaultHeight);

+ frame_generator_capturer_->ChangeResolution(kDefaultWidth * 2,

+ kDefaultHeight * 2);

+ encoder.WaitForResolution(kDefaultWidth * 2, kDefaultHeight * 2);

+ DestroyStreams();

TEST_F(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) {

class StartBitrateObserver : public test::FakeEncoder {

public:

@@ -1319,21 +1389,22 @@ TEST_F(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) {

CreateSendConfig(1, 0, &transport);

Call::Config::BitrateConfig bitrate_config;

- bitrate_config.start_bitrate_bps =

- 2 * video_encoder_config_.streams[0].max_bitrate_bps;

+ bitrate_config.start_bitrate_bps = 2 * video_encoder_config_.max_bitrate_bps;

sender_call_->SetBitrateConfig(bitrate_config);

StartBitrateObserver encoder;

video_send_config_.encoder_settings.encoder = &encoder;

+ // Since this test does not use a capturer, set |internal_source| = true.

+ // Encoder configuration is otherwise updated on the next video frame.

+ video_send_config_.encoder_settings.internal_source = true;

CreateVideoStreams();

EXPECT_TRUE(encoder.WaitForStartBitrate());

- EXPECT_EQ(video_encoder_config_.streams[0].max_bitrate_bps / 1000,

+ EXPECT_EQ(video_encoder_config_.max_bitrate_bps / 1000,

encoder.GetStartBitrateKbps());

- video_encoder_config_.streams[0].max_bitrate_bps =

- 2 * bitrate_config.start_bitrate_bps;

+ video_encoder_config_.max_bitrate_bps = 2 * bitrate_config.start_bitrate_bps;

video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_.Copy());

// New bitrate should be reconfigured above the previous max. As there's no

@@ -1459,8 +1530,9 @@ TEST_F(VideoSendStreamTest, CapturesTextureAndVideoFrames) {

// Prepare five input frames. Send ordinary VideoFrame and texture frames

// alternatively.

std::vector<VideoFrame> input_frames;

- int width = static_cast<int>(video_encoder_config_.streams[0].width);

- int height = static_cast<int>(video_encoder_config_.streams[0].height);

+ int width = 168;

+ int height = 132;

test::FakeNativeHandle* handle1 = new test::FakeNativeHandle();

test::FakeNativeHandle* handle2 = new test::FakeNativeHandle();

test::FakeNativeHandle* handle3 = new test::FakeNativeHandle();

@@ -1478,9 +1550,6 @@ TEST_F(VideoSendStreamTest, CapturesTextureAndVideoFrames) {

video_send_stream_->SetSource(&forwarder);

for (size_t i = 0; i < input_frames.size(); i++) {

forwarder.IncomingCapturedFrame(input_frames[i]);

- // Do not send the next frame too fast, so the frame dropper won't drop it.

- if (i < input_frames.size() - 1)

- SleepMs(1000 / video_encoder_config_.streams[0].max_framerate);

// Wait until the output frame is received before sending the next input

// frame. Or the previous input frame may be replaced without delivering.

observer.WaitOutputFrame();

@@ -1607,9 +1676,12 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {

void PerformTest() override {

EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode.";

- EXPECT_EQ(0u, num_releases());

+ // Expect |num_releases| == 1 since the encoder has been reconfigured

+ // once when the first frame is encoded. Not until at that point is the

+ // frame size known and the encoder can be properly initialized.

+ EXPECT_EQ(1u, num_releases());

stream_->ReconfigureVideoEncoder(std::move(encoder_config_));

- EXPECT_EQ(0u, num_releases());

+ EXPECT_EQ(1u, num_releases());

stream_->Stop();

// Encoder should not be released before destroying the VideoSendStream.

EXPECT_FALSE(IsReleased());

@@ -1631,7 +1703,7 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {

RunBaseTest(&test_encoder);

EXPECT_TRUE(test_encoder.IsReleased());

- EXPECT_EQ(1u, test_encoder.num_releases());

+ EXPECT_EQ(2u, test_encoder.num_releases());

}

TEST_F(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) {

@@ -1714,6 +1786,26 @@ class VideoCodecConfigObserver : public test::SendTest,

}

private:

+ class VideoStreamFactory

+ : public VideoEncoderConfig::VideoStreamFactoryInterface {

+ public:

+ VideoStreamFactory() {}

+ private:

+ std::vector<VideoStream> CreateEncoderStreams(

+ int width,

+ int height,

+ const VideoEncoderConfig& encoder_config) override {

+ std::vector<VideoStream> streams =

+ test::CreateVideoStreams(width, height, encoder_config);

+ for (size_t i = 0; i < streams.size(); ++i) {

+ streams[i].temporal_layer_thresholds_bps.resize(

+ kVideoCodecConfigObserverNumberOfTemporalLayers - 1);

+ }

+ return streams;

+ }

+ };

void ModifyVideoConfigs(

VideoSendStream::Config* send_config,

std::vector<VideoReceiveStream::Config>* receive_configs,

@@ -1721,12 +1813,9 @@ class VideoCodecConfigObserver : public test::SendTest,

send_config->encoder_settings.encoder = this;

send_config->encoder_settings.payload_name = codec_name_;

- for (size_t i = 0; i < encoder_config->streams.size(); ++i) {

- encoder_config->streams[i].temporal_layer_thresholds_bps.resize(

- kVideoCodecConfigObserverNumberOfTemporalLayers - 1);

- }

encoder_config->encoder_specific_settings = GetEncoderSpecificSettings();

+ encoder_config->video_stream_factory =

+ new rtc::RefCountedObject<VideoStreamFactory>();

encoder_config_ = encoder_config->Copy();

}

@@ -1922,6 +2011,26 @@ TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) {

TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) {

static const int kScreencastTargetBitrateKbps = 200;

+ class VideoStreamFactory

+ : public VideoEncoderConfig::VideoStreamFactoryInterface {

+ public:

+ VideoStreamFactory() {}

+ private:

+ std::vector<VideoStream> CreateEncoderStreams(

+ int width,

+ int height,

+ const VideoEncoderConfig& encoder_config) override {

+ std::vector<VideoStream> streams =

+ test::CreateVideoStreams(width, height, encoder_config);

+ EXPECT_TRUE(streams[0].temporal_layer_thresholds_bps.empty());

+ streams[0].temporal_layer_thresholds_bps.push_back(

+ kScreencastTargetBitrateKbps * 1000);

+ return streams;

+ }

+ };

class ScreencastTargetBitrateTest : public test::SendTest,

public test::FakeEncoder {

public:

@@ -1944,11 +2053,9 @@ TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) {

std::vector<VideoReceiveStream::Config>* receive_configs,

VideoEncoderConfig* encoder_config) override {

send_config->encoder_settings.encoder = this;

- EXPECT_EQ(1u, encoder_config->streams.size());

- EXPECT_TRUE(

- encoder_config->streams[0].temporal_layer_thresholds_bps.empty());

- encoder_config->streams[0].temporal_layer_thresholds_bps.push_back(

- kScreencastTargetBitrateKbps * 1000);

+ EXPECT_EQ(1u, encoder_config->number_of_streams);

+ encoder_config->video_stream_factory =

+ new rtc::RefCountedObject<VideoStreamFactory>();

encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen;

}

@@ -1989,7 +2096,8 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {

size_t maxPayloadSize) override {

EXPECT_GE(codecSettings->startBitrate, codecSettings->minBitrate);

EXPECT_LE(codecSettings->startBitrate, codecSettings->maxBitrate);

- if (num_initializations_ == 0) {

+ // First reinitialization happens due to that the frame size is updated.

+ if (num_initializations_ == 0 || num_initializations_ == 1) {

EXPECT_EQ(static_cast<unsigned int>(kMinBitrateKbps),

codecSettings->minBitrate);

EXPECT_EQ(static_cast<unsigned int>(kStartBitrateKbps),

@@ -1997,14 +2105,14 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {

EXPECT_EQ(static_cast<unsigned int>(kMaxBitrateKbps),

codecSettings->maxBitrate);

observation_complete_.Set();

- } else if (num_initializations_ == 1) {

+ } else if (num_initializations_ == 2) {

EXPECT_EQ(static_cast<unsigned int>(kLowerMaxBitrateKbps),

codecSettings->maxBitrate);

// The start bitrate should be kept (-1) and capped to the max bitrate.

// Since this is not an end-to-end call no receiver should have been

// returning a REMB that could lower this estimate.

EXPECT_EQ(codecSettings->startBitrate, codecSettings->maxBitrate);

- } else if (num_initializations_ == 2) {

+ } else if (num_initializations_ == 3) {

EXPECT_EQ(static_cast<unsigned int>(kIncreasedMaxBitrateKbps),

codecSettings->maxBitrate);

// The start bitrate will be whatever the rate BitRateController

@@ -2020,6 +2128,9 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {

int32_t SetRates(uint32_t newBitRate, uint32_t frameRate) override {

{

rtc::CritScope lock(&crit_);

+ if (target_bitrate_ == newBitRate) {

+ return FakeEncoder::SetRates(newBitRate, frameRate);

+ }

target_bitrate_ = newBitRate;

}

bitrate_changed_event_.Set();

@@ -2042,6 +2153,26 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {

return config;

}

+ class VideoStreamFactory

+ : public VideoEncoderConfig::VideoStreamFactoryInterface {

+ public:

+ explicit VideoStreamFactory(int min_bitrate_bps)

+ : min_bitrate_bps_(min_bitrate_bps) {}

+ private:

+ std::vector<VideoStream> CreateEncoderStreams(

+ int width,

+ int height,

+ const VideoEncoderConfig& encoder_config) override {

+ std::vector<VideoStream> streams =

+ test::CreateVideoStreams(width, height, encoder_config);

+ streams[0].min_bitrate_bps = min_bitrate_bps_;

+ return streams;

+ }

+ const int min_bitrate_bps_;

+ };

void ModifyVideoConfigs(

VideoSendStream::Config* send_config,

std::vector<VideoReceiveStream::Config>* receive_configs,

@@ -2049,8 +2180,11 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {

send_config->encoder_settings.encoder = this;

// Set bitrates lower/higher than min/max to make sure they are properly

// capped.

- encoder_config->streams.front().min_bitrate_bps = kMinBitrateKbps * 1000;

- encoder_config->streams.front().max_bitrate_bps = kMaxBitrateKbps * 1000;

+ encoder_config->max_bitrate_bps = kMaxBitrateKbps * 1000;

+ // Create a new StreamFactory to be able to set

+ // |VideoStream.min_bitrate_bps|.

+ encoder_config->video_stream_factory =

+ new rtc::RefCountedObject<VideoStreamFactory>(kMinBitrateKbps * 1000);

encoder_config_ = encoder_config->Copy();

}

@@ -2075,9 +2209,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {

call_->SetBitrateConfig(bitrate_config);

// Encoder rate is capped by EncoderConfig max_bitrate_bps.

WaitForSetRates(kMaxBitrateKbps);

- encoder_config_.streams[0].min_bitrate_bps = 0;

- encoder_config_.streams[0].max_bitrate_bps = kLowerMaxBitrateKbps * 1000;

+ encoder_config_.max_bitrate_bps = kLowerMaxBitrateKbps * 1000;

send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());

ASSERT_TRUE(

init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs));

@@ -2085,10 +2217,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {

<< "Encoder should have been reconfigured with the new value.";

WaitForSetRates(kLowerMaxBitrateKbps);

- encoder_config_.streams[0].target_bitrate_bps =

- encoder_config_.streams[0].min_bitrate_bps;

- encoder_config_.streams[0].max_bitrate_bps =

- kIncreasedMaxBitrateKbps * 1000;

+ encoder_config_.max_bitrate_bps = kIncreasedMaxBitrateKbps * 1000;

send_stream_->ReconfigureVideoEncoder(encoder_config_.Copy());

ASSERT_TRUE(

init_encode_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs));

@@ -2103,6 +2232,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {

rtc::Event bitrate_changed_event_;

rtc::CriticalSection crit_;

uint32_t target_bitrate_ GUARDED_BY(&crit_);

int num_initializations_;

webrtc::Call* call_;

webrtc::VideoSendStream* send_stream_;

@@ -2158,7 +2288,7 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {

std::vector<VideoReceiveStream::Config>* receive_configs,

VideoEncoderConfig* encoder_config) override {

send_config->encoder_settings.encoder = this;

- EXPECT_EQ(kNumStreams, encoder_config->streams.size());

+ EXPECT_EQ(kNumStreams, encoder_config->number_of_streams);

}

size_t GetNumVideoStreams() const override { return kNumStreams; }

@@ -2200,7 +2330,9 @@ class Vp9HeaderObserver : public test::SendTest {

vp9_encoder_(VP9Encoder::Create()),

vp9_settings_(VideoEncoder::GetDefaultVp9Settings()),

packets_sent_(0),

- frames_sent_(0) {}

+ frames_sent_(0),

+ expected_width_(0),

+ expected_height_(0) {}

virtual void ModifyVideoConfigsHook(

VideoSendStream::Config* send_config,

@@ -2212,6 +2344,27 @@ class Vp9HeaderObserver : public test::SendTest {

private:

const int kVp9PayloadType = 105;

+ class VideoStreamFactory

+ : public VideoEncoderConfig::VideoStreamFactoryInterface {

+ public:

+ explicit VideoStreamFactory(size_t number_of_temporal_layers)

+ : number_of_temporal_layers_(number_of_temporal_layers) {}

+ private:

+ std::vector<VideoStream> CreateEncoderStreams(

+ int width,

+ int height,

+ const VideoEncoderConfig& encoder_config) override {

+ std::vector<VideoStream> streams =

+ test::CreateVideoStreams(width, height, encoder_config);

+ streams[0].temporal_layer_thresholds_bps.resize(

+ number_of_temporal_layers_ - 1);

+ return streams;

+ }

+ const size_t number_of_temporal_layers_;

+ };

void ModifyVideoConfigs(

VideoSendStream::Config* send_config,

std::vector<VideoReceiveStream::Config>* receive_configs,

@@ -2222,12 +2375,20 @@ class Vp9HeaderObserver : public test::SendTest {

ModifyVideoConfigsHook(send_config, receive_configs, encoder_config);

encoder_config->encoder_specific_settings = new rtc::RefCountedObject<

VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings_);

- EXPECT_EQ(1u, encoder_config->streams.size());

- encoder_config->streams[0].temporal_layer_thresholds_bps.resize(

- vp9_settings_.numberOfTemporalLayers - 1);

+ EXPECT_EQ(1u, encoder_config->number_of_streams);

+ encoder_config->video_stream_factory =

+ new rtc::RefCountedObject<VideoStreamFactory>(

+ vp9_settings_.numberOfTemporalLayers);

encoder_config_ = encoder_config->Copy();

}

+ void ModifyVideoCaptureStartResolution(int* width,

+ int* height,

+ int* frame_rate) override {

+ expected_width_ = *width;

+ expected_height_ = *height;

+ }

void PerformTest() override {

EXPECT_TRUE(Wait()) << "Test timed out waiting for VP9 packet, num frames "

<< frames_sent_;

@@ -2417,8 +2578,8 @@ class Vp9HeaderObserver : public test::SendTest {

EXPECT_EQ(vp9_settings_.numberOfSpatialLayers, // N_S + 1

vp9.num_spatial_layers);

EXPECT_TRUE(vp9.spatial_layer_resolution_present); // Y:1

- size_t expected_width = encoder_config_.streams[0].width;

- size_t expected_height = encoder_config_.streams[0].height;

+ int expected_width = expected_width_;

+ int expected_height = expected_height_;

for (int i = static_cast<int>(vp9.num_spatial_layers) - 1; i >= 0; --i) {

EXPECT_EQ(expected_width, vp9.width[i]); // WIDTH

EXPECT_EQ(expected_height, vp9.height[i]); // HEIGHT

@@ -2462,6 +2623,8 @@ class Vp9HeaderObserver : public test::SendTest {

RTPVideoHeaderVP9 last_vp9_;

size_t packets_sent_;

size_t frames_sent_;

+ int expected_width_;

+ int expected_height_;

};

TEST_F(VideoSendStreamTest, Vp9NonFlexMode_1Tl1SLayers) {

@@ -2563,15 +2726,22 @@ TEST_F(VideoSendStreamTest, Vp9NonFlexModeSmallResolution) {

vp9_settings_.numberOfTemporalLayers = 1;

vp9_settings_.numberOfSpatialLayers = 1;

- EXPECT_EQ(1u, encoder_config->streams.size());

- encoder_config->streams[0].width = kWidth;

- encoder_config->streams[0].height = kHeight;

+ EXPECT_EQ(1u, encoder_config->number_of_streams);

}

void InspectHeader(const RTPVideoHeaderVP9& vp9_header) override {

if (frames_sent_ > kNumFramesToSend)

observation_complete_.Set();

}

+ void ModifyVideoCaptureStartResolution(int* width,

+ int* height,

+ int* frame_rate) override {

+ expected_width_ = kWidth;

+ expected_height_ = kHeight;

+ *width = kWidth;

+ *height = kHeight;

+ }

} test;

RunBaseTest(&test);

« webrtc/media/engine/webrtcvideoengine2.cc ('K') | « webrtc/video/video_send_stream.cc ('k') | webrtc/video/vie_encoder.h » ('j') | webrtc/video/vie_encoder.h » ('J')