admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replace uses of cricket::VideoRenderer by rtc::VideoSinkInterface.

Browse Source 
Change argument type for VideoProviderInterface::SetVideoPlayout.

Replace VideoMediaChannel::SetRenderer and VideoChannel::SetRenderer
by SetSink.

Alse deleted unused member variables VideoMediaChannel::renderer_ and
VideoChannel::renderer_.

BUG=webrtc:5426

Review URL: https://codereview.webrtc.org/1668493002

Cr-Commit-Position: refs/heads/master@{#11485}
This commit is contained in:
nisse 2016-02-04 01:24:52 -08:00 committed by Commit bot
parent 8cb910d2fd
commit 08582ff075
13 changed files with 94 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
talk/app/webrtc/mediastreamprovider.h
View File

@ -30,11 +30,13 @@
#include "webrtc/base/basictypes.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/media/base/videosinkinterface.h"
namespace cricket {
class AudioRenderer;
class VideoCapturer;
class VideoFrame;
class VideoRenderer;
struct AudioOptions;
struct VideoOptions;
@ -88,9 +90,10 @@ class VideoProviderInterface {
virtual bool SetCaptureDevice(uint32_t ssrc,
cricket::VideoCapturer* camera) = 0;
// Enable/disable the video playout of a remote video track with |ssrc|.
virtual void SetVideoPlayout(uint32_t ssrc,
bool enable,
cricket::VideoRenderer* renderer) = 0;
virtual void SetVideoPlayout(
uint32_t ssrc,
bool enable,
rtc::VideoSinkInterface<cricket::VideoFrame>* sink) = 0;
// Enable sending video on the local video track with |ssrc|.
virtual void SetVideoSend(uint32_t ssrc,
bool enable,

2
talk/app/webrtc/rtpsenderreceiver_unittest.cc
View File

@ -88,7 +88,7 @@ class MockVideoProvider : public VideoProviderInterface {
MOCK_METHOD3(SetVideoPlayout,
void(uint32_t ssrc,
bool enable,
cricket::VideoRenderer* renderer));
rtc::VideoSinkInterface<cricket::VideoFrame>* sink));
MOCK_METHOD3(SetVideoSend,
void(uint32_t ssrc,
bool enable,

13
talk/app/webrtc/webrtcsession.cc
View File

@ -1329,19 +1329,20 @@ bool WebRtcSession::SetCaptureDevice(uint32_t ssrc,
return true;
}
void WebRtcSession::SetVideoPlayout(uint32_t ssrc,
bool enable,
cricket::VideoRenderer* renderer) {
void WebRtcSession::SetVideoPlayout(
uint32_t ssrc,
bool enable,
rtc::VideoSinkInterface<cricket::VideoFrame>* sink) {
ASSERT(signaling_thread()->IsCurrent());
if (!video_channel_) {
LOG(LS_WARNING) << "SetVideoPlayout: No video channel exists.";
return;
}
if (!video_channel_->SetRenderer(ssrc, enable ? renderer : NULL)) {
// Allow that SetRenderer fail if |renderer| is NULL but assert otherwise.
if (!video_channel_->SetSink(ssrc, enable ? sink : NULL)) {
// Allow that SetSink fail if |sink| is NULL but assert otherwise.
// This in the normal case when the underlying media channel has already
// been deleted.
ASSERT(renderer == NULL);
ASSERT(sink == NULL);
}
}

7
talk/app/webrtc/webrtcsession.h
View File

@ -259,9 +259,10 @@ class WebRtcSession : public AudioProviderInterface,
// Implements VideoMediaProviderInterface.
bool SetCaptureDevice(uint32_t ssrc, cricket::VideoCapturer* camera) override;
void SetVideoPlayout(uint32_t ssrc,
bool enable,
cricket::VideoRenderer* renderer) override;
void SetVideoPlayout(
uint32_t ssrc,
bool enable,
rtc::VideoSinkInterface<cricket::VideoFrame>* sink) override;
void SetVideoSend(uint32_t ssrc,
bool enable,
const cricket::VideoOptions* options) override;

8
talk/app/webrtc/webrtcsession_unittest.cc
View File

@ -3438,15 +3438,15 @@ TEST_F(WebRtcSessionTest, SetVideoPlayout) {
CreateAndSetRemoteOfferAndLocalAnswer();
cricket::FakeVideoMediaChannel* channel = media_engine_->GetVideoChannel(0);
ASSERT_TRUE(channel != NULL);
ASSERT_LT(0u, channel->renderers().size());
EXPECT_TRUE(channel->renderers().begin()->second == NULL);
ASSERT_LT(0u, channel->sinks().size());
EXPECT_TRUE(channel->sinks().begin()->second == NULL);
ASSERT_EQ(1u, channel->recv_streams().size());
uint32_t receive_ssrc = channel->recv_streams()[0].first_ssrc();
cricket::FakeVideoRenderer renderer;
session_->SetVideoPlayout(receive_ssrc, true, &renderer);
EXPECT_TRUE(channel->renderers().begin()->second == &renderer);
EXPECT_TRUE(channel->sinks().begin()->second == &renderer);
session_->SetVideoPlayout(receive_ssrc, false, &renderer);
EXPECT_TRUE(channel->renderers().begin()->second == NULL);
EXPECT_TRUE(channel->sinks().begin()->second == NULL);
}
TEST_F(WebRtcSessionTest, SetVideoSend) {

18
talk/media/base/fakemediaengine.h
View File

@ -452,8 +452,9 @@ class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> {
const std::vector<VideoCodec>& codecs() const { return send_codecs(); }
bool rendering() const { return playout(); }
const VideoOptions& options() const { return options_; }
const std::map<uint32_t, VideoRenderer*>& renderers() const {
return renderers_;
const std::map<uint32_t, rtc::VideoSinkInterface<VideoFrame>*>& sinks()
const {
return sinks_;
}
int max_bps() const { return max_bps_; }
virtual bool SetSendParameters(const VideoSendParameters& params) {
@ -481,12 +482,13 @@ class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> {
*send_codec = send_codecs_[0];
return true;
}
virtual bool SetRenderer(uint32_t ssrc, VideoRenderer* r) {
if (ssrc != 0 && renderers_.find(ssrc) == renderers_.end()) {
bool SetSink(uint32_t ssrc,
rtc::VideoSinkInterface<cricket::VideoFrame>* sink) override {
if (ssrc != 0 && sinks_.find(ssrc) == sinks_.end()) {
return false;
}
if (ssrc != 0) {
renderers_[ssrc] = r;
sinks_[ssrc] = sink;
}
return true;
}
@ -512,13 +514,13 @@ class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> {
virtual bool AddRecvStream(const StreamParams& sp) {
if (!RtpHelper<VideoMediaChannel>::AddRecvStream(sp))
return false;
renderers_[sp.first_ssrc()] = NULL;
sinks_[sp.first_ssrc()] = NULL;
return true;
}
virtual bool RemoveRecvStream(uint32_t ssrc) {
if (!RtpHelper<VideoMediaChannel>::RemoveRecvStream(ssrc))
return false;
renderers_.erase(ssrc);
sinks_.erase(ssrc);
return true;
}
@ -554,7 +556,7 @@ class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> {
FakeVideoEngine* engine_;
std::vector<VideoCodec> recv_codecs_;
std::vector<VideoCodec> send_codecs_;
std::map<uint32_t, VideoRenderer*> renderers_;
std::map<uint32_t, rtc::VideoSinkInterface<VideoFrame>*> sinks_;
std::map<uint32_t, VideoCapturer*> capturers_;
VideoOptions options_;
int max_bps_;

13
talk/media/base/mediachannel.h
View File

@ -42,6 +42,7 @@
#include "webrtc/base/sigslot.h"
#include "webrtc/base/socket.h"
#include "webrtc/base/window.h"
#include "webrtc/media/base/videosinkinterface.h"
// TODO(juberti): re-evaluate this include
#include "talk/session/media/audiomonitor.h"
@ -60,7 +61,7 @@ namespace cricket {
class AudioRenderer;
class ScreencastId;
class VideoCapturer;
class VideoRenderer;
class VideoFrame;
struct RtpHeader;
struct VideoFormat;
@ -982,7 +983,7 @@ class VideoMediaChannel : public MediaChannel {
ERROR_PLAY_SRTP_REPLAY, // Packet replay detected.
};
VideoMediaChannel() : renderer_(NULL) {}
VideoMediaChannel() {}
virtual ~VideoMediaChannel() {}
virtual bool SetSendParameters(const VideoSendParameters& params) = 0;
@ -995,17 +996,15 @@ class VideoMediaChannel : public MediaChannel {
virtual bool SetVideoSend(uint32_t ssrc,
bool enable,
const VideoOptions* options) = 0;
// Sets the renderer object to be used for the specified stream.
// Sets the sink object to be used for the specified stream.
// If SSRC is 0, the renderer is used for the 'default' stream.
virtual bool SetRenderer(uint32_t ssrc, VideoRenderer* renderer) = 0;
virtual bool SetSink(uint32_t ssrc,
rtc::VideoSinkInterface<cricket::VideoFrame>* sink) = 0;
// If |ssrc| is 0, replace the default capturer (engine capturer) with
// |capturer|. If |ssrc| is non zero create a new stream with |ssrc| as SSRC.
virtual bool SetCapturer(uint32_t ssrc, VideoCapturer* capturer) = 0;
// Gets quality stats for the channel.
virtual bool GetStats(VideoMediaInfo* info) = 0;
protected:
VideoRenderer *renderer_;
};
enum DataMessageType {

56
talk/media/base/videoengine_unittest.h
View File

@ -172,7 +172,7 @@ class VideoMediaChannelTest : public testing::Test,
EXPECT_TRUE(channel_->AddRecvStream(
cricket::StreamParams::CreateLegacy(kSsrc + 2)));
// Make the second renderer available for use by a new stream.
EXPECT_TRUE(channel_->SetRenderer(kSsrc + 2, &renderer2_));
EXPECT_TRUE(channel_->SetSink(kSsrc + 2, &renderer2_));
}
// Setup an additional stream just to send video. Defer add recv stream.
// This is required if you want to test unsignalled recv of video rtp packets.
@ -180,7 +180,7 @@ class VideoMediaChannelTest : public testing::Test,
// SetUp() already added kSsrc make sure duplicate SSRCs cant be added.
EXPECT_TRUE(channel_->AddRecvStream(
cricket::StreamParams::CreateLegacy(kSsrc)));
EXPECT_TRUE(channel_->SetRenderer(kSsrc, &renderer_));
EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer_));
EXPECT_FALSE(channel_->AddSendStream(
cricket::StreamParams::CreateLegacy(kSsrc)));
EXPECT_TRUE(channel_->AddSendStream(
@ -442,7 +442,7 @@ class VideoMediaChannelTest : public testing::Test,
void SendAndReceive(const cricket::VideoCodec& codec) {
EXPECT_TRUE(SetOneCodec(codec));
EXPECT_TRUE(SetSend(true));
EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_));
EXPECT_EQ(0, renderer_.num_rendered_frames());
EXPECT_TRUE(SendFrame());
EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
@ -453,7 +453,7 @@ class VideoMediaChannelTest : public testing::Test,
int duration_sec, int fps) {
EXPECT_TRUE(SetOneCodec(codec));
EXPECT_TRUE(SetSend(true));
EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_));
EXPECT_EQ(0, renderer_.num_rendered_frames());
for (int i = 0; i < duration_sec; ++i) {
for (int frame = 1; frame <= fps; ++frame) {
@ -533,8 +533,8 @@ class VideoMediaChannelTest : public testing::Test,
cricket::StreamParams::CreateLegacy(1)));
EXPECT_TRUE(channel_->AddRecvStream(
cricket::StreamParams::CreateLegacy(2)));
EXPECT_TRUE(channel_->SetRenderer(1, &renderer1));
EXPECT_TRUE(channel_->SetRenderer(2, &renderer2));
EXPECT_TRUE(channel_->SetSink(1, &renderer1));
EXPECT_TRUE(channel_->SetSink(2, &renderer2));
EXPECT_EQ(0, renderer1.num_rendered_frames());
EXPECT_EQ(0, renderer2.num_rendered_frames());
std::vector<uint32_t> ssrcs;
@ -581,7 +581,7 @@ class VideoMediaChannelTest : public testing::Test,
EXPECT_TRUE(channel_->SetSendParameters(parameters));
EXPECT_TRUE(channel_->AddRecvStream(
cricket::StreamParams::CreateLegacy(kSsrc)));
EXPECT_TRUE(channel_->SetRenderer(kSsrc, &renderer_));
EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer_));
EXPECT_TRUE(SetSend(true));
EXPECT_TRUE(SendFrame());
EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
@ -603,7 +603,7 @@ class VideoMediaChannelTest : public testing::Test,
EXPECT_TRUE(channel_->SetCapturer(5678, capturer.get()));
EXPECT_TRUE(channel_->AddRecvStream(
cricket::StreamParams::CreateLegacy(5678)));
EXPECT_TRUE(channel_->SetRenderer(5678, &renderer2));
EXPECT_TRUE(channel_->SetSink(5678, &renderer2));
EXPECT_TRUE(capturer->CaptureCustomFrame(
kTestWidth, kTestHeight, cricket::FOURCC_I420));
EXPECT_FRAME_ON_RENDERER_WAIT(
@ -691,18 +691,18 @@ class VideoMediaChannelTest : public testing::Test,
}
// Test that we can set the default video renderer before and after
// media is received.
void SetRenderer() {
void SetSink() {
uint8_t data1[] = {
0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
rtc::Buffer packet1(data1, sizeof(data1));
rtc::SetBE32(packet1.data() + 8, kSsrc);
channel_->SetRenderer(kDefaultReceiveSsrc, NULL);
channel_->SetSink(kDefaultReceiveSsrc, NULL);
EXPECT_TRUE(SetDefaultCodec());
EXPECT_TRUE(SetSend(true));
EXPECT_EQ(0, renderer_.num_rendered_frames());
channel_->OnPacketReceived(&packet1, rtc::PacketTime());
EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_));
EXPECT_TRUE(SendFrame());
EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
}
@ -722,7 +722,7 @@ class VideoMediaChannelTest : public testing::Test,
void AddRemoveSendStreams() {
EXPECT_TRUE(SetOneCodec(DefaultCodec()));
EXPECT_TRUE(SetSend(true));
EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_));
EXPECT_TRUE(SendFrame());
EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
EXPECT_GT(NumRtpPackets(), 0);
@ -764,8 +764,8 @@ class VideoMediaChannelTest : public testing::Test,
cricket::StreamParams::CreateLegacy(1)));
EXPECT_TRUE(channel_->AddRecvStream(
cricket::StreamParams::CreateLegacy(2)));
EXPECT_TRUE(channel_->SetRenderer(1, &renderer1));
EXPECT_TRUE(channel_->SetRenderer(2, &renderer2));
EXPECT_TRUE(channel_->SetSink(1, &renderer1));
EXPECT_TRUE(channel_->SetSink(2, &renderer2));
EXPECT_EQ(0, renderer1.num_rendered_frames());
EXPECT_EQ(0, renderer2.num_rendered_frames());
std::vector<uint32_t> ssrcs;
@ -796,7 +796,7 @@ class VideoMediaChannelTest : public testing::Test,
const int time_between_send = TimeBetweenSend(codec);
EXPECT_TRUE(SetOneCodec(codec));
EXPECT_TRUE(SetSend(true));
EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_));
EXPECT_EQ(0, renderer_.num_rendered_frames());
EXPECT_TRUE(SendFrame());
EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
@ -857,7 +857,7 @@ class VideoMediaChannelTest : public testing::Test,
void RemoveCapturerWithoutAdd() {
EXPECT_TRUE(SetOneCodec(DefaultCodec()));
EXPECT_TRUE(SetSend(true));
EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_));
EXPECT_EQ(0, renderer_.num_rendered_frames());
EXPECT_TRUE(SendFrame());
EXPECT_FRAME_WAIT(1, 640, 400, kTimeout);
@ -886,15 +886,15 @@ class VideoMediaChannelTest : public testing::Test,
// Set up the stream associated with the engine.
EXPECT_TRUE(channel_->AddRecvStream(
cricket::StreamParams::CreateLegacy(kSsrc)));
EXPECT_TRUE(channel_->SetRenderer(kSsrc, &renderer_));
EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer_));
cricket::VideoFormat capture_format; // default format
capture_format.interval = cricket::VideoFormat::FpsToInterval(30);
// Set up additional stream 1.
cricket::FakeVideoRenderer renderer1;
EXPECT_FALSE(channel_->SetRenderer(1, &renderer1));
EXPECT_FALSE(channel_->SetSink(1, &renderer1));
EXPECT_TRUE(channel_->AddRecvStream(
cricket::StreamParams::CreateLegacy(1)));
EXPECT_TRUE(channel_->SetRenderer(1, &renderer1));
EXPECT_TRUE(channel_->SetSink(1, &renderer1));
EXPECT_TRUE(channel_->AddSendStream(
cricket::StreamParams::CreateLegacy(1)));
rtc::scoped_ptr<cricket::FakeVideoCapturer> capturer1(
@ -903,10 +903,10 @@ class VideoMediaChannelTest : public testing::Test,
EXPECT_EQ(cricket::CS_RUNNING, capturer1->Start(capture_format));
// Set up additional stream 2.
cricket::FakeVideoRenderer renderer2;
EXPECT_FALSE(channel_->SetRenderer(2, &renderer2));
EXPECT_FALSE(channel_->SetSink(2, &renderer2));
EXPECT_TRUE(channel_->AddRecvStream(
cricket::StreamParams::CreateLegacy(2)));
EXPECT_TRUE(channel_->SetRenderer(2, &renderer2));
EXPECT_TRUE(channel_->SetSink(2, &renderer2));
EXPECT_TRUE(channel_->AddSendStream(
cricket::StreamParams::CreateLegacy(2)));
rtc::scoped_ptr<cricket::FakeVideoCapturer> capturer2(
@ -956,7 +956,7 @@ class VideoMediaChannelTest : public testing::Test,
cricket::FakeVideoRenderer renderer;
EXPECT_TRUE(channel_->AddRecvStream(
cricket::StreamParams::CreateLegacy(kSsrc)));
EXPECT_TRUE(channel_->SetRenderer(kSsrc, &renderer));
EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer));
EXPECT_EQ(0, renderer.num_rendered_frames());
EXPECT_TRUE(SendFrame());
@ -985,7 +985,7 @@ class VideoMediaChannelTest : public testing::Test,
// Tests that we can adapt video resolution with 16:10 aspect ratio properly.
void AdaptResolution16x10() {
EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_));
cricket::VideoCodec codec(DefaultCodec());
codec.width = 640;
codec.height = 400;
@ -999,7 +999,7 @@ class VideoMediaChannelTest : public testing::Test,
}
// Tests that we can adapt video resolution with 4:3 aspect ratio properly.
void AdaptResolution4x3() {
EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_));
cricket::VideoCodec codec(DefaultCodec());
codec.width = 640;
codec.height = 400;
@ -1019,7 +1019,7 @@ class VideoMediaChannelTest : public testing::Test,
codec.width = codec.height = codec.framerate = 0;
EXPECT_TRUE(SetOneCodec(codec));
EXPECT_TRUE(SetSend(true));
EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_));
EXPECT_EQ(0, renderer_.num_rendered_frames());
EXPECT_TRUE(SendFrame());
EXPECT_TRUE(SendFrame());
@ -1079,7 +1079,7 @@ class VideoMediaChannelTest : public testing::Test,
codec.height = 240;
EXPECT_TRUE(SetOneCodec(codec));
EXPECT_TRUE(SetSend(true));
EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_));
EXPECT_EQ(0, renderer_.num_rendered_frames());
EXPECT_TRUE(SendFrame());
EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
@ -1102,7 +1102,7 @@ class VideoMediaChannelTest : public testing::Test,
cricket::FOURCC_I420));
EXPECT_TRUE(channel_->SetCapturer(kSsrc, &video_capturer));
EXPECT_TRUE(SetSend(true));
EXPECT_TRUE(channel_->SetRenderer(kDefaultReceiveSsrc, &renderer_));
EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_));
EXPECT_EQ(0, renderer_.num_rendered_frames());
// Mute the channel and expect black output frame.
int frame_count = 0;
@ -1196,7 +1196,7 @@ class VideoMediaChannelTest : public testing::Test,
cricket::StreamParams::CreateLegacy(new_ssrc)));
EXPECT_TRUE(channel_->AddRecvStream(
cricket::StreamParams::CreateLegacy(new_ssrc)));
EXPECT_TRUE(channel_->SetRenderer(new_ssrc, &renderer_));
EXPECT_TRUE(channel_->SetSink(new_ssrc, &renderer_));
EXPECT_FALSE(channel_->AddRecvStream(
cricket::StreamParams::CreateLegacy(new_ssrc)));

27
talk/media/webrtc/webrtcvideoengine2.cc
View File

@ -471,7 +471,7 @@ void* WebRtcVideoChannel2::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
}
DefaultUnsignalledSsrcHandler::DefaultUnsignalledSsrcHandler()
: default_recv_ssrc_(0), default_renderer_(NULL) {}
: default_recv_ssrc_(0), default_sink_(NULL) {}
UnsignalledSsrcHandler::Action DefaultUnsignalledSsrcHandler::OnUnsignalledSsrc(
WebRtcVideoChannel2* channel,
@ -488,21 +488,22 @@ UnsignalledSsrcHandler::Action DefaultUnsignalledSsrcHandler::OnUnsignalledSsrc(
LOG(LS_WARNING) << "Could not create default receive stream.";
}
channel->SetRenderer(ssrc, default_renderer_);
channel->SetSink(ssrc, default_sink_);
default_recv_ssrc_ = ssrc;
return kDeliverPacket;
}
VideoRenderer* DefaultUnsignalledSsrcHandler::GetDefaultRenderer() const {
return default_renderer_;
rtc::VideoSinkInterface<VideoFrame>*
DefaultUnsignalledSsrcHandler::GetDefaultSink() const {
return default_sink_;
}
void DefaultUnsignalledSsrcHandler::SetDefaultRenderer(
void DefaultUnsignalledSsrcHandler::SetDefaultSink(
VideoMediaChannel* channel,
VideoRenderer* renderer) {
default_renderer_ = renderer;
rtc::VideoSinkInterface<VideoFrame>* sink) {
default_sink_ = sink;
if (default_recv_ssrc_ != 0) {
channel->SetRenderer(default_recv_ssrc_, default_renderer_);
channel->SetSink(default_recv_ssrc_, default_sink_);
}
}
@ -1220,11 +1221,11 @@ bool WebRtcVideoChannel2::RemoveRecvStream(uint32_t ssrc) {
return true;
}
bool WebRtcVideoChannel2::SetRenderer(uint32_t ssrc, VideoRenderer* renderer) {
LOG(LS_INFO) << "SetRenderer: ssrc:" << ssrc << " "
<< (renderer ? "(ptr)" : "NULL");
bool WebRtcVideoChannel2::SetSink(uint32_t ssrc,
rtc::VideoSinkInterface<VideoFrame>* sink) {
LOG(LS_INFO) << "SetSink: ssrc:" << ssrc << " " << (sink ? "(ptr)" : "NULL");
if (ssrc == 0) {
default_unsignalled_ssrc_handler_.SetDefaultRenderer(this, renderer);
default_unsignalled_ssrc_handler_.SetDefaultSink(this, sink);
return true;
}
@ -1235,7 +1236,7 @@ bool WebRtcVideoChannel2::SetRenderer(uint32_t ssrc, VideoRenderer* renderer) {
return false;
}
it->second->SetSink(renderer);
it->second->SetSink(sink);
return true;
}

10
talk/media/webrtc/webrtcvideoengine2.h
View File

@ -96,12 +96,13 @@ class DefaultUnsignalledSsrcHandler : public UnsignalledSsrcHandler {
Action OnUnsignalledSsrc(WebRtcVideoChannel2* channel,
uint32_t ssrc) override;
VideoRenderer* GetDefaultRenderer() const;
void SetDefaultRenderer(VideoMediaChannel* channel, VideoRenderer* renderer);
rtc::VideoSinkInterface<VideoFrame>* GetDefaultSink() const;
void SetDefaultSink(VideoMediaChannel* channel,
rtc::VideoSinkInterface<VideoFrame>* sink);
private:
uint32_t default_recv_ssrc_;
VideoRenderer* default_renderer_;
rtc::VideoSinkInterface<VideoFrame>* default_sink_;
};
// WebRtcVideoEngine2 is used for the new native WebRTC Video API (webrtc:1667).
@ -165,7 +166,8 @@ class WebRtcVideoChannel2 : public VideoMediaChannel,
bool AddRecvStream(const StreamParams& sp) override;
bool AddRecvStream(const StreamParams& sp, bool default_stream);
bool RemoveRecvStream(uint32_t ssrc) override;
bool SetRenderer(uint32_t ssrc, VideoRenderer* renderer) override;
bool SetSink(uint32_t ssrc,
rtc::VideoSinkInterface<VideoFrame>* sink) override;
bool GetStats(VideoMediaInfo* info) override;
bool SetCapturer(uint32_t ssrc, VideoCapturer* capturer) override;

4
talk/media/webrtc/webrtcvideoengine2_unittest.cc
View File

@ -766,7 +766,7 @@ WEBRTC_BASE_TEST(SetSendBandwidth);
WEBRTC_BASE_TEST(SetSendSsrc);
WEBRTC_BASE_TEST(SetSendSsrcAfterSetCodecs);
WEBRTC_BASE_TEST(SetRenderer);
WEBRTC_BASE_TEST(SetSink);
WEBRTC_BASE_TEST(AddRemoveSendStreams);
@ -1771,7 +1771,7 @@ TEST_F(WebRtcVideoChannel2Test, EstimatesNtpStartTimeCorrectly) {
FakeVideoReceiveStream* stream = AddRecvStream();
cricket::FakeVideoRenderer renderer;
EXPECT_TRUE(channel_->SetRenderer(last_ssrc_, &renderer));
EXPECT_TRUE(channel_->SetSink(last_ssrc_, &renderer));
webrtc::VideoFrame video_frame;
CreateBlackFrame(&video_frame, 4, 4);

8
talk/session/media/channel.cc
View File

@ -1650,7 +1650,6 @@ VideoChannel::VideoChannel(rtc::Thread* thread,
transport_controller,
content_name,
rtcp),
renderer_(NULL),
previous_we_(rtc::WE_CLOSE) {}
bool VideoChannel::Init() {
@ -1679,9 +1678,10 @@ VideoChannel::~VideoChannel() {
Deinit();
}
bool VideoChannel::SetRenderer(uint32_t ssrc, VideoRenderer* renderer) {
worker_thread()->Invoke<void>(Bind(
&VideoMediaChannel::SetRenderer, media_channel(), ssrc, renderer));
bool VideoChannel::SetSink(uint32_t ssrc,
rtc::VideoSinkInterface<VideoFrame>* sink) {
worker_thread()->Invoke<void>(
Bind(&VideoMediaChannel::SetSink, media_channel(), ssrc, sink));
return true;
}

4
talk/session/media/channel.h
View File

@ -50,6 +50,7 @@
#include "webrtc/base/network.h"
#include "webrtc/base/sigslot.h"
#include "webrtc/base/window.h"
#include "webrtc/media/base/videosinkinterface.h"
#include "webrtc/p2p/base/transportcontroller.h"
#include "webrtc/p2p/client/socketmonitor.h"
@ -454,7 +455,7 @@ class VideoChannel : public BaseChannel {
return static_cast<VideoMediaChannel*>(BaseChannel::media_channel());
}
bool SetRenderer(uint32_t ssrc, VideoRenderer* renderer);
bool SetSink(uint32_t ssrc, rtc::VideoSinkInterface<VideoFrame>* sink);
// TODO(pthatcher): Refactor to use a "capture id" instead of an
// ssrc here as the "key".
@ -507,7 +508,6 @@ class VideoChannel : public BaseChannel {
virtual void OnStateChange(VideoCapturer* capturer, CaptureState ev);
bool GetLocalSsrc(const VideoCapturer* capturer, uint32_t* ssrc);
VideoRenderer* renderer_;
ScreencastMap screencast_capturers_;
rtc::scoped_ptr<VideoMediaMonitor> media_monitor_;