OLD | NEW |
---|---|
1 /* | 1 /* |
2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 4 * Use of this source code is governed by a BSD-style license |
5 * that can be found in the LICENSE file in the root of the source | 5 * that can be found in the LICENSE file in the root of the source |
6 * tree. An additional intellectual property rights grant can be found | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 #include "webrtc/video/video_quality_test.h" | 10 #include "webrtc/video/video_quality_test.h" |
11 | 11 |
12 #include <stdio.h> | 12 #include <stdio.h> |
13 #include <algorithm> | 13 #include <algorithm> |
14 #include <deque> | 14 #include <deque> |
15 #include <map> | 15 #include <map> |
16 #include <set> | 16 #include <set> |
17 #include <sstream> | 17 #include <sstream> |
18 #include <string> | 18 #include <string> |
19 #include <vector> | 19 #include <vector> |
20 | 20 |
21 #if defined(WEBRTC_ANDROID) | |
22 #include "webrtc/modules/video_coding/codecs/test/android_test_initializer.h" | |
23 #include "webrtc/sdk/android/src/jni/androidmediadecoder_jni.h" | |
24 #include "webrtc/sdk/android/src/jni/androidmediaencoder_jni.h" | |
25 #elif defined(WEBRTC_IOS) | |
26 #include "webrtc/modules/video_coding/codecs/test/objc_codec_h264_test.h" | |
27 #endif | |
28 | |
21 #include "webrtc/api/optional.h" | 29 #include "webrtc/api/optional.h" |
22 #include "webrtc/call/call.h" | 30 #include "webrtc/call/call.h" |
23 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h" | 31 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h" |
24 #include "webrtc/logging/rtc_event_log/rtc_event_log.h" | 32 #include "webrtc/logging/rtc_event_log/rtc_event_log.h" |
33 #include "webrtc/media/engine/internalencoderfactory.h" | |
34 #include "webrtc/media/engine/videoencodersoftwarefallbackwrapper.h" | |
25 #include "webrtc/media/engine/webrtcvideoengine.h" | 35 #include "webrtc/media/engine/webrtcvideoengine.h" |
26 #include "webrtc/modules/audio_mixer/audio_mixer_impl.h" | 36 #include "webrtc/modules/audio_mixer/audio_mixer_impl.h" |
27 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h" | 37 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h" |
28 #include "webrtc/modules/rtp_rtcp/source/rtp_format.h" | 38 #include "webrtc/modules/rtp_rtcp/source/rtp_format.h" |
29 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h" | 39 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h" |
30 #include "webrtc/modules/video_coding/codecs/h264/include/h264.h" | 40 #include "webrtc/modules/video_coding/codecs/h264/include/h264.h" |
31 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h" | 41 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h" |
32 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8_common_types.h" | 42 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8_common_types.h" |
33 #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h" | 43 #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h" |
34 #include "webrtc/rtc_base/checks.h" | 44 #include "webrtc/rtc_base/checks.h" |
(...skipping 1084 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1119 rtc::PlatformThread stats_polling_thread_; | 1129 rtc::PlatformThread stats_polling_thread_; |
1120 rtc::Event comparison_available_event_; | 1130 rtc::Event comparison_available_event_; |
1121 std::deque<FrameComparison> comparisons_ GUARDED_BY(comparison_lock_); | 1131 std::deque<FrameComparison> comparisons_ GUARDED_BY(comparison_lock_); |
1122 rtc::Event done_; | 1132 rtc::Event done_; |
1123 | 1133 |
1124 std::unique_ptr<test::RtpFileWriter> rtp_file_writer_; | 1134 std::unique_ptr<test::RtpFileWriter> rtp_file_writer_; |
1125 Clock* const clock_; | 1135 Clock* const clock_; |
1126 const int64_t start_ms_; | 1136 const int64_t start_ms_; |
1127 }; | 1137 }; |
1128 | 1138 |
1129 class Vp8EncoderFactory : public cricket::WebRtcVideoEncoderFactory { | |
1130 public: | |
1131 Vp8EncoderFactory() { | |
1132 supported_codecs_.push_back(cricket::VideoCodec("VP8")); | |
1133 } | |
1134 ~Vp8EncoderFactory() override { RTC_CHECK(live_encoders_.empty()); } | |
1135 | |
1136 const std::vector<cricket::VideoCodec>& supported_codecs() const override { | |
1137 return supported_codecs_; | |
1138 } | |
1139 | |
1140 VideoEncoder* CreateVideoEncoder(const cricket::VideoCodec& codec) override { | |
1141 VideoEncoder* encoder = VP8Encoder::Create(); | |
1142 live_encoders_.insert(encoder); | |
1143 return encoder; | |
1144 } | |
1145 | |
1146 void DestroyVideoEncoder(VideoEncoder* encoder) override { | |
1147 auto it = live_encoders_.find(encoder); | |
1148 RTC_CHECK(it != live_encoders_.end()); | |
1149 live_encoders_.erase(it); | |
1150 delete encoder; | |
1151 } | |
1152 | |
1153 private: | |
1154 std::vector<cricket::VideoCodec> supported_codecs_; | |
1155 std::set<VideoEncoder*> live_encoders_; | |
1156 }; | |
1157 | |
1158 VideoQualityTest::VideoQualityTest() | 1139 VideoQualityTest::VideoQualityTest() |
1159 : clock_(Clock::GetRealTimeClock()), receive_logs_(0), send_logs_(0) { | 1140 : clock_(Clock::GetRealTimeClock()), receive_logs_(0), send_logs_(0) { |
1160 payload_type_map_ = test::CallTest::payload_type_map_; | 1141 payload_type_map_ = test::CallTest::payload_type_map_; |
1161 RTC_DCHECK(payload_type_map_.find(kPayloadTypeH264) == | 1142 RTC_DCHECK(payload_type_map_.find(kPayloadTypeH264) == |
1162 payload_type_map_.end()); | 1143 payload_type_map_.end()); |
1163 RTC_DCHECK(payload_type_map_.find(kPayloadTypeVP8) == | 1144 RTC_DCHECK(payload_type_map_.find(kPayloadTypeVP8) == |
1164 payload_type_map_.end()); | 1145 payload_type_map_.end()); |
1165 RTC_DCHECK(payload_type_map_.find(kPayloadTypeVP9) == | 1146 RTC_DCHECK(payload_type_map_.find(kPayloadTypeVP9) == |
1166 payload_type_map_.end()); | 1147 payload_type_map_.end()); |
1167 payload_type_map_[kPayloadTypeH264] = webrtc::MediaType::VIDEO; | 1148 payload_type_map_[kPayloadTypeH264] = webrtc::MediaType::VIDEO; |
1168 payload_type_map_[kPayloadTypeVP8] = webrtc::MediaType::VIDEO; | 1149 payload_type_map_[kPayloadTypeVP8] = webrtc::MediaType::VIDEO; |
1169 payload_type_map_[kPayloadTypeVP9] = webrtc::MediaType::VIDEO; | 1150 payload_type_map_[kPayloadTypeVP9] = webrtc::MediaType::VIDEO; |
1151 | |
1152 #if defined(WEBRTC_ANDROID) | |
1153 InitializeAndroidObjects(); | |
1154 #endif | |
1170 } | 1155 } |
1171 | 1156 |
1172 VideoQualityTest::Params::Params() | 1157 VideoQualityTest::Params::Params() |
1173 : call({false, Call::Config::BitrateConfig(), 0}), | 1158 : call({false, Call::Config::BitrateConfig(), 0}), |
1174 video({false, 640, 480, 30, 50, 800, 800, false, "VP8", 1, -1, 0, false, | 1159 video({false, 640, 480, 30, 50, 800, 800, false, "VP8", false, false, 1, |
1175 false, ""}), | 1160 -1, 0, false, false, ""}), |
1176 audio({false, false, false}), | 1161 audio({false, false, false}), |
1177 screenshare({false, false, 10, 0}), | 1162 screenshare({false, false, 10, 0}), |
1178 analyzer({"", 0.0, 0.0, 0, "", ""}), | 1163 analyzer({"", 0.0, 0.0, 0, "", ""}), |
1179 pipe(), | 1164 pipe(), |
1180 ss({std::vector<VideoStream>(), 0, 0, -1, std::vector<SpatialLayer>()}), | 1165 ss({std::vector<VideoStream>(), 0, 0, -1, std::vector<SpatialLayer>()}), |
1181 logging({false, "", "", ""}) {} | 1166 logging({false, "", "", ""}) {} |
1182 | 1167 |
1183 VideoQualityTest::Params::~Params() = default; | 1168 VideoQualityTest::Params::~Params() = default; |
1184 | 1169 |
1185 void VideoQualityTest::TestBody() {} | 1170 void VideoQualityTest::TestBody() {} |
(...skipping 218 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1404 | 1389 |
1405 void VideoQualityTest::SetupVideo(Transport* send_transport, | 1390 void VideoQualityTest::SetupVideo(Transport* send_transport, |
1406 Transport* recv_transport) { | 1391 Transport* recv_transport) { |
1407 if (params_.logging.logs) | 1392 if (params_.logging.logs) |
1408 trace_to_stderr_.reset(new test::TraceToStderr); | 1393 trace_to_stderr_.reset(new test::TraceToStderr); |
1409 | 1394 |
1410 size_t num_video_streams = params_.ss.streams.size(); | 1395 size_t num_video_streams = params_.ss.streams.size(); |
1411 size_t num_flexfec_streams = params_.video.flexfec ? 1 : 0; | 1396 size_t num_flexfec_streams = params_.video.flexfec ? 1 : 0; |
1412 CreateSendConfig(num_video_streams, 0, num_flexfec_streams, send_transport); | 1397 CreateSendConfig(num_video_streams, 0, num_flexfec_streams, send_transport); |
1413 | 1398 |
1399 if (params_.video.hw_encoder) { | |
1400 #if defined(WEBRTC_ANDROID) | |
1401 video_encoder_factory_.reset(new jni::MediaCodecVideoEncoderFactory()); | |
1402 #elif defined(WEBRTC_IOS) | |
1403 video_encoder_factory_ = CreateObjCEncoderFactory(); | |
1404 #else | |
1405 RTC_NOTREACHED() << "Only support HW encoder on Android and iOS."; | |
1406 #endif | |
1407 } else { | |
1408 video_encoder_factory_.reset(new cricket::InternalEncoderFactory()); | |
1409 } | |
1410 | |
1411 cricket::VideoCodec codec; | |
1414 int payload_type; | 1412 int payload_type; |
1415 if (params_.video.codec == "H264") { | 1413 if (params_.video.codec == "H264") { |
1416 video_encoder_.reset(H264Encoder::Create(cricket::VideoCodec("H264"))); | 1414 // TODO(brandtr): Add support for high profile here. |
1415 codec = cricket::VideoCodec(cricket::kH264CodecName); | |
1416 video_encoder_.reset(video_encoder_factory_->CreateVideoEncoder(codec)); | |
1417 payload_type = kPayloadTypeH264; | 1417 payload_type = kPayloadTypeH264; |
1418 } else if (params_.video.codec == "VP8") { | 1418 } else if (params_.video.codec == "VP8") { |
1419 codec = cricket::VideoCodec(cricket::kVp8CodecName); | |
1419 if (params_.screenshare.enabled && params_.ss.streams.size() > 1) { | 1420 if (params_.screenshare.enabled && params_.ss.streams.size() > 1) { |
1420 // Simulcast screenshare needs a simulcast encoder adapter to work, since | 1421 // Simulcast screenshare needs a simulcast encoder adapter to work, |
1421 // encoders usually can't natively do simulcast with different frame rates | 1422 // since encoders usually can't natively do simulcast with |
1422 // for the different layers. | 1423 // different frame rates for the different layers. |
1423 video_encoder_.reset( | 1424 video_encoder_.reset( |
1424 new SimulcastEncoderAdapter(new Vp8EncoderFactory())); | 1425 new SimulcastEncoderAdapter(video_encoder_factory_.get())); |
1425 } else { | 1426 } else { |
1426 video_encoder_.reset(VP8Encoder::Create()); | 1427 video_encoder_.reset(video_encoder_factory_->CreateVideoEncoder(codec)); |
1427 } | 1428 } |
1428 payload_type = kPayloadTypeVP8; | 1429 payload_type = kPayloadTypeVP8; |
1429 } else if (params_.video.codec == "VP9") { | 1430 } else if (params_.video.codec == "VP9") { |
1430 video_encoder_.reset(VP9Encoder::Create()); | 1431 codec = cricket::VideoCodec(cricket::kVp9CodecName); |
1432 video_encoder_.reset(video_encoder_factory_->CreateVideoEncoder(codec)); | |
1431 payload_type = kPayloadTypeVP9; | 1433 payload_type = kPayloadTypeVP9; |
1432 } else { | 1434 } else { |
1433 RTC_NOTREACHED() << "Codec not supported!"; | 1435 RTC_NOTREACHED() << "Codec not supported!"; |
1434 return; | 1436 return; |
1435 } | 1437 } |
1438 | |
1439 if (params_.video.sw_fallback_encoder) { | |
1440 video_encoder_ = rtc::MakeUnique<VideoEncoderSoftwareFallbackWrapper>( | |
1441 codec, std::move(video_encoder_)); | |
1442 } | |
1443 | |
1436 video_send_config_.encoder_settings.encoder = video_encoder_.get(); | 1444 video_send_config_.encoder_settings.encoder = video_encoder_.get(); |
1437 video_send_config_.encoder_settings.payload_name = params_.video.codec; | 1445 video_send_config_.encoder_settings.payload_name = params_.video.codec; |
1438 video_send_config_.encoder_settings.payload_type = payload_type; | 1446 video_send_config_.encoder_settings.payload_type = payload_type; |
1439 video_send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs; | 1447 video_send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs; |
1440 video_send_config_.rtp.rtx.payload_type = kSendRtxPayloadType; | 1448 video_send_config_.rtp.rtx.payload_type = kSendRtxPayloadType; |
1441 for (size_t i = 0; i < num_video_streams; ++i) | 1449 for (size_t i = 0; i < num_video_streams; ++i) |
1442 video_send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]); | 1450 video_send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]); |
1443 | 1451 |
1444 video_send_config_.rtp.extensions.clear(); | 1452 video_send_config_.rtp.extensions.clear(); |
1445 if (params_.call.send_side_bwe) { | 1453 if (params_.call.send_side_bwe) { |
(...skipping 26 matching lines...) Expand all Loading... | |
1472 new rtc::RefCountedObject<cricket::EncoderStreamFactory>( | 1480 new rtc::RefCountedObject<cricket::EncoderStreamFactory>( |
1473 params_.video.codec, params_.ss.streams[0].max_qp, | 1481 params_.video.codec, params_.ss.streams[0].max_qp, |
1474 params_.video.fps, params_.screenshare.enabled, true); | 1482 params_.video.fps, params_.screenshare.enabled, true); |
1475 } else { | 1483 } else { |
1476 video_encoder_config_.video_stream_factory = | 1484 video_encoder_config_.video_stream_factory = |
1477 new rtc::RefCountedObject<VideoStreamFactory>(params_.ss.streams); | 1485 new rtc::RefCountedObject<VideoStreamFactory>(params_.ss.streams); |
1478 } | 1486 } |
1479 | 1487 |
1480 video_encoder_config_.spatial_layers = params_.ss.spatial_layers; | 1488 video_encoder_config_.spatial_layers = params_.ss.spatial_layers; |
1481 | 1489 |
1482 CreateMatchingReceiveConfigs(recv_transport); | 1490 CreateMatchingReceiveConfigs(recv_transport); |
brandtr
2017/09/08 11:31:14
The decoder is instantiated during this call. Addi
| |
1483 | 1491 |
1484 const bool decode_all_receive_streams = | 1492 const bool decode_all_receive_streams = |
1485 params_.ss.selected_stream == params_.ss.streams.size(); | 1493 params_.ss.selected_stream == params_.ss.streams.size(); |
1486 | 1494 |
1487 for (size_t i = 0; i < num_video_streams; ++i) { | 1495 for (size_t i = 0; i < num_video_streams; ++i) { |
1488 video_receive_configs_[i].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; | 1496 video_receive_configs_[i].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; |
1489 video_receive_configs_[i].rtp.rtx_ssrc = kSendRtxSsrcs[i]; | 1497 video_receive_configs_[i].rtp.rtx_ssrc = kSendRtxSsrcs[i]; |
1490 video_receive_configs_[i] | 1498 video_receive_configs_[i] |
1491 .rtp.rtx_associated_payload_types[kSendRtxPayloadType] = payload_type; | 1499 .rtp.rtx_associated_payload_types[kSendRtxPayloadType] = payload_type; |
1492 video_receive_configs_[i].rtp.transport_cc = params_.call.send_side_bwe; | 1500 video_receive_configs_[i].rtp.transport_cc = params_.call.send_side_bwe; |
(...skipping 459 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1952 test::kTransportSequenceNumberExtensionId)); | 1960 test::kTransportSequenceNumberExtensionId)); |
1953 audio_send_config_.min_bitrate_bps = kOpusMinBitrateBps; | 1961 audio_send_config_.min_bitrate_bps = kOpusMinBitrateBps; |
1954 audio_send_config_.max_bitrate_bps = kOpusBitrateFbBps; | 1962 audio_send_config_.max_bitrate_bps = kOpusBitrateFbBps; |
1955 } | 1963 } |
1956 audio_send_config_.send_codec_spec = | 1964 audio_send_config_.send_codec_spec = |
1957 rtc::Optional<AudioSendStream::Config::SendCodecSpec>( | 1965 rtc::Optional<AudioSendStream::Config::SendCodecSpec>( |
1958 {kAudioSendPayloadType, | 1966 {kAudioSendPayloadType, |
1959 {"OPUS", 48000, 2, | 1967 {"OPUS", 48000, 2, |
1960 {{"usedtx", (params_.audio.dtx ? "1" : "0")}, | 1968 {{"usedtx", (params_.audio.dtx ? "1" : "0")}, |
1961 {"stereo", "1"}}}}); | 1969 {"stereo", "1"}}}}); |
1962 audio_send_config_.encoder_factory = encoder_factory_; | 1970 audio_send_config_.encoder_factory = audio_encoder_factory_; |
1963 audio_send_stream_ = sender_call_->CreateAudioSendStream(audio_send_config_); | 1971 audio_send_stream_ = sender_call_->CreateAudioSendStream(audio_send_config_); |
1964 | 1972 |
1965 AudioReceiveStream::Config audio_config; | 1973 AudioReceiveStream::Config audio_config; |
1966 audio_config.rtp.local_ssrc = kReceiverLocalAudioSsrc; | 1974 audio_config.rtp.local_ssrc = kReceiverLocalAudioSsrc; |
1967 audio_config.rtcp_send_transport = transport; | 1975 audio_config.rtcp_send_transport = transport; |
1968 audio_config.voe_channel_id = receive_channel_id; | 1976 audio_config.voe_channel_id = receive_channel_id; |
1969 audio_config.rtp.remote_ssrc = audio_send_config_.rtp.ssrc; | 1977 audio_config.rtp.remote_ssrc = audio_send_config_.rtp.ssrc; |
1970 audio_config.rtp.transport_cc = params_.call.send_side_bwe; | 1978 audio_config.rtp.transport_cc = params_.call.send_side_bwe; |
1971 audio_config.rtp.extensions = audio_send_config_.rtp.extensions; | 1979 audio_config.rtp.extensions = audio_send_config_.rtp.extensions; |
1972 audio_config.decoder_factory = decoder_factory_; | 1980 audio_config.decoder_factory = audio_decoder_factory_; |
1973 audio_config.decoder_map = {{kAudioSendPayloadType, {"OPUS", 48000, 2}}}; | 1981 audio_config.decoder_map = {{kAudioSendPayloadType, {"OPUS", 48000, 2}}}; |
1974 if (params_.video.enabled && params_.audio.sync_video) | 1982 if (params_.video.enabled && params_.audio.sync_video) |
1975 audio_config.sync_group = kSyncGroup; | 1983 audio_config.sync_group = kSyncGroup; |
1976 | 1984 |
1977 *audio_receive_stream = | 1985 *audio_receive_stream = |
1978 receiver_call_->CreateAudioReceiveStream(audio_config); | 1986 receiver_call_->CreateAudioReceiveStream(audio_config); |
1979 } | 1987 } |
1980 | 1988 |
1981 void VideoQualityTest::RunWithRenderers(const Params& params) { | 1989 void VideoQualityTest::RunWithRenderers(const Params& params) { |
1982 std::unique_ptr<test::LayerFilteringTransport> send_transport; | 1990 std::unique_ptr<test::LayerFilteringTransport> send_transport; |
1983 std::unique_ptr<test::DirectTransport> recv_transport; | 1991 std::unique_ptr<test::DirectTransport> recv_transport; |
1984 ::VoiceEngineState voe; | 1992 ::VoiceEngineState voe; |
1985 std::unique_ptr<test::VideoRenderer> local_preview; | 1993 std::unique_ptr<test::VideoRenderer> local_preview; |
1986 std::vector<std::unique_ptr<test::VideoRenderer>> loopback_renderers; | 1994 std::vector<std::unique_ptr<test::VideoRenderer>> loopback_renderers; |
1987 AudioReceiveStream* audio_receive_stream = nullptr; | 1995 AudioReceiveStream* audio_receive_stream = nullptr; |
1988 | 1996 |
1989 task_queue_.SendTask([&]() { | 1997 task_queue_.SendTask([&]() { |
1990 params_ = params; | 1998 params_ = params; |
1991 CheckParams(); | 1999 CheckParams(); |
1992 | 2000 |
1993 // TODO(ivica): Remove bitrate_config and use the default Call::Config(), to | 2001 // TODO(ivica): Remove bitrate_config and use the default Call::Config(), to |
1994 // match the full stack tests. | 2002 // match the full stack tests. |
1995 Call::Config call_config(event_log_.get()); | 2003 Call::Config call_config(event_log_.get()); |
1996 call_config.bitrate_config = params_.call.call_bitrate_config; | 2004 call_config.bitrate_config = params_.call.call_bitrate_config; |
1997 | 2005 |
1998 rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing( | 2006 rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing( |
1999 webrtc::AudioProcessing::Create()); | 2007 webrtc::AudioProcessing::Create()); |
2000 | 2008 |
2001 if (params_.audio.enabled) { | 2009 if (params_.audio.enabled) { |
2002 CreateVoiceEngine(&voe, audio_processing.get(), decoder_factory_); | 2010 CreateVoiceEngine(&voe, audio_processing.get(), audio_decoder_factory_); |
2003 AudioState::Config audio_state_config; | 2011 AudioState::Config audio_state_config; |
2004 audio_state_config.voice_engine = voe.voice_engine; | 2012 audio_state_config.voice_engine = voe.voice_engine; |
2005 audio_state_config.audio_mixer = AudioMixerImpl::Create(); | 2013 audio_state_config.audio_mixer = AudioMixerImpl::Create(); |
2006 audio_state_config.audio_processing = audio_processing; | 2014 audio_state_config.audio_processing = audio_processing; |
2007 call_config.audio_state = AudioState::Create(audio_state_config); | 2015 call_config.audio_state = AudioState::Create(audio_state_config); |
2008 } | 2016 } |
2009 | 2017 |
2010 CreateCalls(call_config, call_config); | 2018 CreateCalls(call_config, call_config); |
2011 | 2019 |
2012 // TODO(minyue): consider if this is a good transport even for audio only | 2020 // TODO(minyue): consider if this is a good transport even for audio only |
(...skipping 158 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2171 if (!params_.logging.encoded_frame_base_path.empty()) { | 2179 if (!params_.logging.encoded_frame_base_path.empty()) { |
2172 std::ostringstream str; | 2180 std::ostringstream str; |
2173 str << receive_logs_++; | 2181 str << receive_logs_++; |
2174 std::string path = | 2182 std::string path = |
2175 params_.logging.encoded_frame_base_path + "." + str.str() + ".recv.ivf"; | 2183 params_.logging.encoded_frame_base_path + "." + str.str() + ".recv.ivf"; |
2176 stream->EnableEncodedFrameRecording(rtc::CreatePlatformFile(path), | 2184 stream->EnableEncodedFrameRecording(rtc::CreatePlatformFile(path), |
2177 100000000); | 2185 100000000); |
2178 } | 2186 } |
2179 } | 2187 } |
2180 } // namespace webrtc | 2188 } // namespace webrtc |
OLD | NEW |