Use SingleThreadedTaskQueue in DirectTransport

webrtc/video/video_quality_test.cc

 /*
  *  Copyright (c) 2015 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 "webrtc/video/video_quality_test.h"
@@ skipping 19 matching lines @@
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8_common_types.h"
 #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/cpu_time.h"
 #include "webrtc/rtc_base/event.h"
 #include "webrtc/rtc_base/format_macros.h"
 #include "webrtc/rtc_base/memory_usage.h"
 #include "webrtc/rtc_base/optional.h"
 #include "webrtc/rtc_base/platform_file.h"
+#include "webrtc/rtc_base/ptr_util.h"
 #include "webrtc/rtc_base/timeutils.h"
 #include "webrtc/system_wrappers/include/cpu_info.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/layer_filtering_transport.h"
 #include "webrtc/test/run_loop.h"
 #include "webrtc/test/statistics.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/test/testsupport/frame_writer.h"
 #include "webrtc/test/vcm_capturer.h"
@@ skipping 1712 matching lines @@
           clock_));
       ASSERT_TRUE(video_capturer_) << "Could not create capturer for "
                                    << params_.video.clip_name
                                    << ".yuv. Is this resource file present?";
     }
   }
   RTC_DCHECK(video_capturer_.get());
 }
 
 void VideoQualityTest::RunWithAnalyzer(const Params& params) {
+  std::unique_ptr<test::LayerFilteringTransport> send_transport;
+  std::unique_ptr<test::DirectTransport> recv_transport;
+  FILE* graph_data_output_file = nullptr;
+  std::unique_ptr<VideoAnalyzer> analyzer;
+
   params_ = params;
 
   RTC_CHECK(!params_.audio.enabled);
   // TODO(ivica): Merge with RunWithRenderer and use a flag / argument to
   // differentiate between the analyzer and the renderer case.
   CheckParams();
 
-  FILE* graph_data_output_file = nullptr;
   if (!params_.analyzer.graph_data_output_filename.empty()) {
     graph_data_output_file =
         fopen(params_.analyzer.graph_data_output_filename.c_str(), "w");
     RTC_CHECK(graph_data_output_file)
         << "Can't open the file " << params_.analyzer.graph_data_output_filename
         << "!";
   }
 
   if (!params.logging.rtc_event_log_name.empty()) {
     event_log_ = RtcEventLog::Create(clock_);
     bool event_log_started =
         event_log_->StartLogging(params.logging.rtc_event_log_name, -1);
     RTC_DCHECK(event_log_started);
   }
 
   Call::Config call_config(event_log_.get());
   call_config.bitrate_config = params.call.call_bitrate_config;
-  CreateCalls(call_config, call_config);
 
-  test::LayerFilteringTransport send_transport(
-      params_.pipe, sender_call_.get(), kPayloadTypeVP8, kPayloadTypeVP9,
-      params_.video.selected_tl, params_.ss.selected_sl, payload_type_map_);
+  task_queue_.SendTask([this, &call_config, &send_transport,
+                        &recv_transport]() {
+    CreateCalls(call_config, call_config);
 
-  test::DirectTransport recv_transport(params_.pipe, receiver_call_.get(),
-                                       payload_type_map_);
+    send_transport = rtc::MakeUnique<test::LayerFilteringTransport>(
+        &task_queue_, params_.pipe, sender_call_.get(), kPayloadTypeVP8,
+        kPayloadTypeVP9, params_.video.selected_tl, params_.ss.selected_sl,
+        payload_type_map_);
+
+    recv_transport = rtc::MakeUnique<test::DirectTransport>(
+        &task_queue_, params_.pipe, receiver_call_.get(), payload_type_map_);
+  });
 
   std::string graph_title = params_.analyzer.graph_title;
   if (graph_title.empty())
     graph_title = VideoQualityTest::GenerateGraphTitle();
-
   bool is_quick_test_enabled = field_trial::IsEnabled("WebRTC-QuickPerfTest");
-  VideoAnalyzer analyzer(
-      &send_transport, params_.analyzer.test_label,
+  analyzer = rtc::MakeUnique<VideoAnalyzer>(
+      send_transport.get(), params_.analyzer.test_label,
       params_.analyzer.avg_psnr_threshold, params_.analyzer.avg_ssim_threshold,
       is_quick_test_enabled
           ? kFramesSentInQuickTest
           : params_.analyzer.test_durations_secs * params_.video.fps,
       graph_data_output_file, graph_title,
       kVideoSendSsrcs[params_.ss.selected_stream],
       kSendRtxSsrcs[params_.ss.selected_stream],
       static_cast<size_t>(params_.ss.selected_stream), params.ss.selected_sl,
       params_.video.selected_tl, is_quick_test_enabled, clock_,
       params_.logging.rtp_dump_name);
-  analyzer.SetCall(sender_call_.get());
-  analyzer.SetReceiver(receiver_call_->Receiver());
-  send_transport.SetReceiver(&analyzer);
-  recv_transport.SetReceiver(sender_call_->Receiver());
 
-  SetupVideo(&analyzer, &recv_transport);
-  SetupThumbnails(&analyzer, &recv_transport);
-  video_receive_configs_[params_.ss.selected_stream].renderer = &analyzer;
-  video_send_config_.pre_encode_callback = analyzer.pre_encode_proxy();
-  RTC_DCHECK(!video_send_config_.post_encode_callback);
-  video_send_config_.post_encode_callback = analyzer.encode_timing_proxy();
+  task_queue_.SendTask([&]() {
+    analyzer->SetCall(sender_call_.get());
+    analyzer->SetReceiver(receiver_call_->Receiver());
+    send_transport->SetReceiver(analyzer.get());
+    recv_transport->SetReceiver(sender_call_->Receiver());
 
-  SetupScreenshareOrSVC();
+    SetupVideo(analyzer.get(), recv_transport.get());
+    SetupThumbnails(analyzer.get(), recv_transport.get());
+    video_receive_configs_[params_.ss.selected_stream].renderer =
+        analyzer.get();
+    video_send_config_.pre_encode_callback = analyzer->pre_encode_proxy();
+    RTC_DCHECK(!video_send_config_.post_encode_callback);
+    video_send_config_.post_encode_callback = analyzer->encode_timing_proxy();
 
-  CreateFlexfecStreams();
-  CreateVideoStreams();
-  analyzer.SetSendStream(video_send_stream_);
-  if (video_receive_streams_.size() == 1)
-    analyzer.SetReceiveStream(video_receive_streams_[0]);
+    SetupScreenshareOrSVC();
 
-  video_send_stream_->SetSource(analyzer.OutputInterface(),
-                                degradation_preference_);
+    CreateFlexfecStreams();
+    CreateVideoStreams();
+    analyzer->SetSendStream(video_send_stream_);
+    if (video_receive_streams_.size() == 1)
+      analyzer->SetReceiveStream(video_receive_streams_[0]);
 
-  SetupThumbnailCapturers(params_.call.num_thumbnails);
-  for (size_t i = 0; i < thumbnail_send_streams_.size(); ++i) {
-    thumbnail_send_streams_[i]->SetSource(thumbnail_capturers_[i].get(),
-                                          degradation_preference_);
-  }
+    video_send_stream_->SetSource(analyzer->OutputInterface(),
+                                  degradation_preference_);
 
-  CreateCapturer();
+    SetupThumbnailCapturers(params_.call.num_thumbnails);
+    for (size_t i = 0; i < thumbnail_send_streams_.size(); ++i) {
+      thumbnail_send_streams_[i]->SetSource(thumbnail_capturers_[i].get(),
+                                            degradation_preference_);
+    }
 
-  analyzer.SetSource(video_capturer_.get(), params_.ss.infer_streams);
+    CreateCapturer();
 
-  StartEncodedFrameLogs(video_send_stream_);
-  StartEncodedFrameLogs(video_receive_streams_[params_.ss.selected_stream]);
-  video_send_stream_->Start();
-  for (VideoSendStream* thumbnail_send_stream : thumbnail_send_streams_)
-    thumbnail_send_stream->Start();
-  for (VideoReceiveStream* receive_stream : video_receive_streams_)
-    receive_stream->Start();
-  for (VideoReceiveStream* thumbnail_receive_stream :
-       thumbnail_receive_streams_)
-    thumbnail_receive_stream->Start();
+    analyzer->SetSource(video_capturer_.get(), params_.ss.infer_streams);
 
-  analyzer.StartMeasuringCpuProcessTime();
+    StartEncodedFrameLogs(video_send_stream_);
+    StartEncodedFrameLogs(video_receive_streams_[params_.ss.selected_stream]);
+    video_send_stream_->Start();
+    for (VideoSendStream* thumbnail_send_stream : thumbnail_send_streams_)
+      thumbnail_send_stream->Start();
+    for (VideoReceiveStream* receive_stream : video_receive_streams_)
+      receive_stream->Start();
+    for (VideoReceiveStream* thumbnail_receive_stream :
+         thumbnail_receive_streams_)
+      thumbnail_receive_stream->Start();
 
-  video_capturer_->Start();
-  for (std::unique_ptr<test::VideoCapturer>& video_caputurer :
-       thumbnail_capturers_) {
-    video_caputurer->Start();
-  }
+    analyzer->StartMeasuringCpuProcessTime();
 
-  analyzer.Wait();
+    video_capturer_->Start();
+    for (std::unique_ptr<test::VideoCapturer>& video_caputurer :
+         thumbnail_capturers_) {
+      video_caputurer->Start();
+    }
+  });
 
-  send_transport.StopSending();
-  recv_transport.StopSending();
+  analyzer->Wait();
 
-  for (std::unique_ptr<test::VideoCapturer>& video_caputurer :
-       thumbnail_capturers_)
-    video_caputurer->Stop();
-  video_capturer_->Stop();
-  for (VideoReceiveStream* thumbnail_receive_stream :
-       thumbnail_receive_streams_)
-    thumbnail_receive_stream->Stop();
-  for (VideoReceiveStream* receive_stream : video_receive_streams_)
-    receive_stream->Stop();
-  for (VideoSendStream* thumbnail_send_stream : thumbnail_send_streams_)
-    thumbnail_send_stream->Stop();
-  video_send_stream_->Stop();
+  task_queue_.SendTask([&]() {
+    send_transport.reset();
+    recv_transport.reset();
 
-  DestroyStreams();
-  DestroyThumbnailStreams();
+    for (std::unique_ptr<test::VideoCapturer>& video_caputurer :
+         thumbnail_capturers_)
+      video_caputurer->Stop();
+    video_capturer_->Stop();
+    for (VideoReceiveStream* thumbnail_receive_stream :
+         thumbnail_receive_streams_)
+      thumbnail_receive_stream->Stop();
+    for (VideoReceiveStream* receive_stream : video_receive_streams_)
+      receive_stream->Stop();
+    for (VideoSendStream* thumbnail_send_stream : thumbnail_send_streams_)
+      thumbnail_send_stream->Stop();
+    video_send_stream_->Stop();
 
-  event_log_->StopLogging();
-  if (graph_data_output_file)
-    fclose(graph_data_output_file);
+    DestroyStreams();
+    DestroyThumbnailStreams();
+
+    event_log_->StopLogging();
+    if (graph_data_output_file)
+      fclose(graph_data_output_file);
+
+    DestroyCalls();
+  });
 }
 
 void VideoQualityTest::SetupAudio(int send_channel_id,
                                   int receive_channel_id,
                                   Transport* transport,
                                   AudioReceiveStream** audio_receive_stream) {
   audio_send_config_ = AudioSendStream::Config(transport);
   audio_send_config_.voe_channel_id = send_channel_id;
   audio_send_config_.rtp.ssrc = kAudioSendSsrc;
 
@@ skipping 26 matching lines @@
   audio_config.decoder_factory = decoder_factory_;
   audio_config.decoder_map = {{kAudioSendPayloadType, {"OPUS", 48000, 2}}};
   if (params_.video.enabled && params_.audio.sync_video)
     audio_config.sync_group = kSyncGroup;
 
   *audio_receive_stream =
       receiver_call_->CreateAudioReceiveStream(audio_config);
 }
 
 void VideoQualityTest::RunWithRenderers(const Params& params) {
-  params_ = params;
-  CheckParams();
+  std::unique_ptr<test::LayerFilteringTransport> send_transport;
+  std::unique_ptr<test::DirectTransport> recv_transport;
+  ::VoiceEngineState voe;
+  std::unique_ptr<test::VideoRenderer> local_preview;
+  std::vector<std::unique_ptr<test::VideoRenderer>> loopback_renderers;
+  AudioReceiveStream* audio_receive_stream = nullptr;
 
-  // TODO(ivica): Remove bitrate_config and use the default Call::Config(), to
-  // match the full stack tests.
-  Call::Config call_config(event_log_.get());
-  call_config.bitrate_config = params_.call.call_bitrate_config;
+  task_queue_.SendTask([&]() {
+    params_ = params;
+    CheckParams();
 
-  ::VoiceEngineState voe;
-  rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing(
-      webrtc::AudioProcessing::Create());
+    // TODO(ivica): Remove bitrate_config and use the default Call::Config(), to
+    // match the full stack tests.
+    Call::Config call_config(event_log_.get());
+    call_config.bitrate_config = params_.call.call_bitrate_config;
 
-  if (params_.audio.enabled) {
-    CreateVoiceEngine(&voe, audio_processing.get(), decoder_factory_);
-    AudioState::Config audio_state_config;
-    audio_state_config.voice_engine = voe.voice_engine;
-    audio_state_config.audio_mixer = AudioMixerImpl::Create();
-    audio_state_config.audio_processing = audio_processing;
-    call_config.audio_state = AudioState::Create(audio_state_config);
-  }
+    rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing(
+        webrtc::AudioProcessing::Create());
 
-  CreateCalls(call_config, call_config);
-
-  // TODO(minyue): consider if this is a good transport even for audio only
-  // calls.
-  test::LayerFilteringTransport send_transport(
-      params.pipe, sender_call_.get(), kPayloadTypeVP8, kPayloadTypeVP9,
-      params.video.selected_tl, params_.ss.selected_sl, payload_type_map_);
-
-  test::DirectTransport recv_transport(params_.pipe, receiver_call_.get(),
-                                       payload_type_map_);
-
-  // TODO(ivica): Use two calls to be able to merge with RunWithAnalyzer or at
-  // least share as much code as possible. That way this test would also match
-  // the full stack tests better.
-  send_transport.SetReceiver(receiver_call_->Receiver());
-  recv_transport.SetReceiver(sender_call_->Receiver());
-
-  std::unique_ptr<test::VideoRenderer> local_preview;
-  std::vector<std::unique_ptr<test::VideoRenderer>> loopback_renderers_;
-  if (params_.video.enabled) {
-    // Create video renderers.
-    local_preview.reset(test::VideoRenderer::Create(
-        "Local Preview", params_.video.width, params_.video.height));
-
-    const size_t selected_stream_id = params_.ss.selected_stream;
-    const size_t num_streams = params_.ss.streams.size();
-
-    if (selected_stream_id == num_streams) {
-      for (size_t stream_id = 0; stream_id < num_streams; ++stream_id) {
-        std::ostringstream oss;
-        oss << "Loopback Video - Stream #" << static_cast<int>(stream_id);
-        loopback_renderers_.emplace_back(test::VideoRenderer::Create(
-            oss.str().c_str(), params_.ss.streams[stream_id].width,
-            params_.ss.streams[stream_id].height));
-      }
-    } else {
-      loopback_renderers_.emplace_back(test::VideoRenderer::Create(
-          "Loopback Video", params_.ss.streams[selected_stream_id].width,
-          params_.ss.streams[selected_stream_id].height));
+    if (params_.audio.enabled) {
+      CreateVoiceEngine(&voe, audio_processing.get(), decoder_factory_);
+      AudioState::Config audio_state_config;
+      audio_state_config.voice_engine = voe.voice_engine;
+      audio_state_config.audio_mixer = AudioMixerImpl::Create();
+      audio_state_config.audio_processing = audio_processing;
+      call_config.audio_state = AudioState::Create(audio_state_config);
     }
 
-    SetupVideo(&send_transport, &recv_transport);
+    CreateCalls(call_config, call_config);
 
-    video_send_config_.pre_encode_callback = local_preview.get();
-    if (selected_stream_id == num_streams) {
-      for (size_t stream_id = 0; stream_id < num_streams; ++stream_id) {
-        video_receive_configs_[stream_id].renderer =
-            loopback_renderers_[stream_id].get();
+    // TODO(minyue): consider if this is a good transport even for audio only
+    // calls.
+    send_transport = rtc::MakeUnique<test::LayerFilteringTransport>(
+        &task_queue_, params.pipe, sender_call_.get(), kPayloadTypeVP8,
+        kPayloadTypeVP9, params.video.selected_tl, params_.ss.selected_sl,
+        payload_type_map_);
+
+    recv_transport = rtc::MakeUnique<test::DirectTransport>(
+        &task_queue_, params_.pipe, receiver_call_.get(), payload_type_map_);
+
+    // TODO(ivica): Use two calls to be able to merge with RunWithAnalyzer or at
+    // least share as much code as possible. That way this test would also match
+    // the full stack tests better.
+    send_transport->SetReceiver(receiver_call_->Receiver());
+    recv_transport->SetReceiver(sender_call_->Receiver());
+
+    if (params_.video.enabled) {
+      // Create video renderers.
+      local_preview.reset(test::VideoRenderer::Create(
+          "Local Preview", params_.video.width, params_.video.height));
+
+      const size_t selected_stream_id = params_.ss.selected_stream;
+      const size_t num_streams = params_.ss.streams.size();
+
+      if (selected_stream_id == num_streams) {
+        for (size_t stream_id = 0; stream_id < num_streams; ++stream_id) {
+          std::ostringstream oss;
+          oss << "Loopback Video - Stream #" << static_cast<int>(stream_id);
+          loopback_renderers.emplace_back(test::VideoRenderer::Create(
+              oss.str().c_str(), params_.ss.streams[stream_id].width,
+              params_.ss.streams[stream_id].height));
+        }
+      } else {
+        loopback_renderers.emplace_back(test::VideoRenderer::Create(
+            "Loopback Video", params_.ss.streams[selected_stream_id].width,
+            params_.ss.streams[selected_stream_id].height));
+      }
+
+      SetupVideo(send_transport.get(), recv_transport.get());
+
+      video_send_config_.pre_encode_callback = local_preview.get();
+      if (selected_stream_id == num_streams) {
+        for (size_t stream_id = 0; stream_id < num_streams; ++stream_id) {
+          video_receive_configs_[stream_id].renderer =
+              loopback_renderers[stream_id].get();
+          if (params_.audio.enabled && params_.audio.sync_video)
+            video_receive_configs_[stream_id].sync_group = kSyncGroup;
+        }
+      } else {
+        video_receive_configs_[selected_stream_id].renderer =
+            loopback_renderers.back().get();
         if (params_.audio.enabled && params_.audio.sync_video)
-          video_receive_configs_[stream_id].sync_group = kSyncGroup;
+          video_receive_configs_[selected_stream_id].sync_group = kSyncGroup;
       }
-    } else {
-      video_receive_configs_[selected_stream_id].renderer =
-          loopback_renderers_.back().get();
-      if (params_.audio.enabled && params_.audio.sync_video)
-        video_receive_configs_[selected_stream_id].sync_group = kSyncGroup;
+
+      if (params_.screenshare.enabled)
+        SetupScreenshareOrSVC();
+
+      CreateFlexfecStreams();
+      CreateVideoStreams();
+
+      CreateCapturer();
+      video_send_stream_->SetSource(video_capturer_.get(),
+                                    degradation_preference_);
     }
 
-    if (params_.screenshare.enabled)
-      SetupScreenshareOrSVC();
+    if (params_.audio.enabled) {
+      SetupAudio(voe.send_channel_id, voe.receive_channel_id,
+                 send_transport.get(), &audio_receive_stream);
+    }
 
-    CreateFlexfecStreams();
-    CreateVideoStreams();
+    for (VideoReceiveStream* receive_stream : video_receive_streams_)
+      StartEncodedFrameLogs(receive_stream);
+    StartEncodedFrameLogs(video_send_stream_);
 
-    CreateCapturer();
-    video_send_stream_->SetSource(video_capturer_.get(),
-                                  degradation_preference_);
-  }
+    // Start sending and receiving video.
+    if (params_.video.enabled) {
+      for (VideoReceiveStream* video_receive_stream : video_receive_streams_)
+        video_receive_stream->Start();
 
-  AudioReceiveStream* audio_receive_stream = nullptr;
-  if (params_.audio.enabled) {
-    SetupAudio(voe.send_channel_id, voe.receive_channel_id, &send_transport,
-               &audio_receive_stream);
-  }
+      video_send_stream_->Start();
+      video_capturer_->Start();
+    }
 
-  for (VideoReceiveStream* receive_stream : video_receive_streams_)
-    StartEncodedFrameLogs(receive_stream);
-  StartEncodedFrameLogs(video_send_stream_);
+    if (params_.audio.enabled) {
+      // Start receiving audio.
+      audio_receive_stream->Start();
+      EXPECT_EQ(0, voe.base->StartPlayout(voe.receive_channel_id));
 
-  // Start sending and receiving video.
-  if (params_.video.enabled) {
-    for (VideoReceiveStream* video_receive_stream : video_receive_streams_)
-      video_receive_stream->Start();
-
-    video_send_stream_->Start();
-    video_capturer_->Start();
-  }
-
-  if (params_.audio.enabled) {
-    // Start receiving audio.
-    audio_receive_stream->Start();
-    EXPECT_EQ(0, voe.base->StartPlayout(voe.receive_channel_id));
-
-    // Start sending audio.
-    audio_send_stream_->Start();
-    EXPECT_EQ(0, voe.base->StartSend(voe.send_channel_id));
-  }
+      // Start sending audio.
+      audio_send_stream_->Start();
+      EXPECT_EQ(0, voe.base->StartSend(voe.send_channel_id));
+    }
+  });
 
   test::PressEnterToContinue();
 
-  if (params_.audio.enabled) {
-    // Stop sending audio.
-    EXPECT_EQ(0, voe.base->StopSend(voe.send_channel_id));
-    audio_send_stream_->Stop();
+  task_queue_.SendTask([&]() {
+    if (params_.audio.enabled) {
+      // Stop sending audio.
+      EXPECT_EQ(0, voe.base->StopSend(voe.send_channel_id));
+      audio_send_stream_->Stop();
 
-    // Stop receiving audio.
-    EXPECT_EQ(0, voe.base->StopPlayout(voe.receive_channel_id));
-    audio_receive_stream->Stop();
-    sender_call_->DestroyAudioSendStream(audio_send_stream_);
-    receiver_call_->DestroyAudioReceiveStream(audio_receive_stream);
-  }
+      // Stop receiving audio.
+      EXPECT_EQ(0, voe.base->StopPlayout(voe.receive_channel_id));
+      audio_receive_stream->Stop();
+      sender_call_->DestroyAudioSendStream(audio_send_stream_);
+      receiver_call_->DestroyAudioReceiveStream(audio_receive_stream);
+    }
 
-  // Stop receiving and sending video.
-  if (params_.video.enabled) {
-    video_capturer_->Stop();
-    video_send_stream_->Stop();
-    for (FlexfecReceiveStream* flexfec_receive_stream :
-         flexfec_receive_streams_) {
-      for (VideoReceiveStream* video_receive_stream : video_receive_streams_) {
-        video_receive_stream->RemoveSecondarySink(flexfec_receive_stream);
+    // Stop receiving and sending video.
+    if (params_.video.enabled) {
+      video_capturer_->Stop();
+      video_send_stream_->Stop();
+      for (FlexfecReceiveStream* flexfec_receive_stream :
+           flexfec_receive_streams_) {
+        for (VideoReceiveStream* video_receive_stream :
+             video_receive_streams_) {
+          video_receive_stream->RemoveSecondarySink(flexfec_receive_stream);
+        }
+        receiver_call_->DestroyFlexfecReceiveStream(flexfec_receive_stream);
       }
-      receiver_call_->DestroyFlexfecReceiveStream(flexfec_receive_stream);
+      for (VideoReceiveStream* receive_stream : video_receive_streams_) {
+        receive_stream->Stop();
+        receiver_call_->DestroyVideoReceiveStream(receive_stream);
+      }
+      sender_call_->DestroyVideoSendStream(video_send_stream_);
     }
-    for (VideoReceiveStream* receive_stream : video_receive_streams_) {
-      receive_stream->Stop();
-      receiver_call_->DestroyVideoReceiveStream(receive_stream);
-    }
-    sender_call_->DestroyVideoSendStream(video_send_stream_);
-  }
 
-  send_transport.StopSending();
-  recv_transport.StopSending();
+    send_transport.reset();
+    recv_transport.reset();
 
-  if (params_.audio.enabled)
-    DestroyVoiceEngine(&voe);
+    if (params_.audio.enabled)
+      DestroyVoiceEngine(&voe);
+
+    recv_transport.reset();
+    send_transport.reset();
+    local_preview.reset();
+    loopback_renderers.clear();
+
+    DestroyCalls();
+  });
 }
 
 void VideoQualityTest::StartEncodedFrameLogs(VideoSendStream* stream) {
   if (!params_.logging.encoded_frame_base_path.empty()) {
     std::ostringstream str;
     str << send_logs_++;
     std::string prefix =
         params_.logging.encoded_frame_base_path + "." + str.str() + ".send.";
     stream->EnableEncodedFrameRecording(
         std::vector<rtc::PlatformFile>(
             {rtc::CreatePlatformFile(prefix + "1.ivf"),
              rtc::CreatePlatformFile(prefix + "2.ivf"),
              rtc::CreatePlatformFile(prefix + "3.ivf")}),
         100000000);
   }
 }
 
 void VideoQualityTest::StartEncodedFrameLogs(VideoReceiveStream* stream) {
   if (!params_.logging.encoded_frame_base_path.empty()) {
     std::ostringstream str;
     str << receive_logs_++;
     std::string path =
         params_.logging.encoded_frame_base_path + "." + str.str() + ".recv.ivf";
     stream->EnableEncodedFrameRecording(rtc::CreatePlatformFile(path),
                                         100000000);
   }
 }
 }  // namespace webrtc