zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Delete class webrtc::VideoRenderer and its header file.

Browse Source 
To replace the SmoothsRenderedFrames method, added a corresponding
flag to VideoReceiveStream::Config instead.

BUG=webrtc:5426

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

Cr-Commit-Position: refs/heads/master@{#12102}
This commit is contained in:
nisse
2016-03-23 04:48:10 -07:00
committed by Commit bot
parent 1509fa1aa9
commit 7ade7b3282
19 changed files with 56 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
webrtc/DEPS
View File

@ -44,7 +44,10 @@ specific_include_rules = {
"video_frame\.h": [
"+webrtc/common_video",
],
"video_renderer\.h": [
"video_receive_stream\.h": [
"+webrtc/media/base",
],
"video_send_stream\.h": [
"+webrtc/media/base",
],
}

4
webrtc/call/call_perf_tests.cc
View File

@ -75,7 +75,7 @@ class CallPerfTest : public test::CallTest {
};
class VideoRtcpAndSyncObserver : public test::RtpRtcpObserver,
public VideoRenderer {
public rtc::VideoSinkInterface<VideoFrame> {
static const int kInSyncThresholdMs = 50;
static const int kStartupTimeMs = 2000;
static const int kMinRunTimeMs = 30000;
@ -346,7 +346,7 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
int start_time_ms,
int run_time_ms) {
class CaptureNtpTimeObserver : public test::EndToEndTest,
public VideoRenderer {
public rtc::VideoSinkInterface<VideoFrame> {
public:
CaptureNtpTimeObserver(const FakeNetworkPipe::Config& net_config,
int threshold_ms,

1
webrtc/common_video/incoming_video_stream.cc
View File

@ -28,7 +28,6 @@
#include "webrtc/system_wrappers/include/event_wrapper.h"
#include "webrtc/system_wrappers/include/tick_util.h"
#include "webrtc/system_wrappers/include/trace.h"
#include "webrtc/video_renderer.h"
namespace webrtc {

3
webrtc/media/base/videosinkinterface.h
View File

@ -11,6 +11,9 @@
#ifndef WEBRTC_MEDIA_BASE_VIDEOSINKINTERFACE_H_
#define WEBRTC_MEDIA_BASE_VIDEOSINKINTERFACE_H_
// TODO(nisse): Consider moving this interface (and possibly
// VideoSourceInterface too) from media/base to common_video, to
// reduce dependency cycles.
namespace rtc {
template <typename VideoFrameT>

13
webrtc/media/engine/webrtcvideoengine2.cc
View File

@ -1184,10 +1184,12 @@ bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp,
config.rtp.remb = send_codec_ ? HasRemb(send_codec_->codec) : false;
config.rtp.transport_cc =
send_codec_ ? HasTransportCc(send_codec_->codec) : false;
config.disable_prerenderer_smoothing =
video_config_.disable_prerenderer_smoothing;
receive_streams_[ssrc] = new WebRtcVideoReceiveStream(
call_, sp, config, external_decoder_factory_, default_stream,
recv_codecs_, video_config_.disable_prerenderer_smoothing);
recv_codecs_);
return true;
}
@ -2206,8 +2208,7 @@ WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
const webrtc::VideoReceiveStream::Config& config,
WebRtcVideoDecoderFactory* external_decoder_factory,
bool default_stream,
const std::vector<VideoCodecSettings>& recv_codecs,
bool disable_prerenderer_smoothing)
const std::vector<VideoCodecSettings>& recv_codecs)
: call_(call),
ssrcs_(sp.ssrcs),
ssrc_groups_(sp.ssrc_groups),
@ -2215,7 +2216,6 @@ WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
default_stream_(default_stream),
config_(config),
external_decoder_factory_(external_decoder_factory),
disable_prerenderer_smoothing_(disable_prerenderer_smoothing),
sink_(NULL),
last_width_(-1),
last_height_(-1),
@ -2434,11 +2434,6 @@ void WebRtcVideoChannel2::WebRtcVideoReceiveStream::OnFrame(
sink_->OnFrame(render_frame);
}
bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::SmoothsRenderedFrames()
const {
return disable_prerenderer_smoothing_;
}
bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::IsDefaultStream() const {
return default_stream_;
}

13
webrtc/media/engine/webrtcvideoengine2.h
View File

@ -31,7 +31,6 @@
#include "webrtc/transport.h"
#include "webrtc/video_frame.h"
#include "webrtc/video_receive_stream.h"
#include "webrtc/video_renderer.h"
#include "webrtc/video_send_stream.h"
namespace webrtc {
@ -396,8 +395,10 @@ class WebRtcVideoChannel2 : public VideoMediaChannel, public webrtc::Transport {
// Wrapper for the receiver part, contains configs etc. that are needed to
// reconstruct the underlying VideoReceiveStream. Also serves as a wrapper
// between webrtc::VideoRenderer and cricket::VideoRenderer.
class WebRtcVideoReceiveStream : public webrtc::VideoRenderer {
// between rtc::VideoSinkInterface<webrtc::VideoFrame> and
// rtc::VideoSinkInterface<cricket::VideoFrame>.
class WebRtcVideoReceiveStream
: public rtc::VideoSinkInterface<webrtc::VideoFrame> {
public:
WebRtcVideoReceiveStream(
webrtc::Call* call,
@ -405,8 +406,7 @@ class WebRtcVideoChannel2 : public VideoMediaChannel, public webrtc::Transport {
const webrtc::VideoReceiveStream::Config& config,
WebRtcVideoDecoderFactory* external_decoder_factory,
bool default_stream,
const std::vector<VideoCodecSettings>& recv_codecs,
bool disable_prerenderer_smoothing);
const std::vector<VideoCodecSettings>& recv_codecs);
~WebRtcVideoReceiveStream();
const std::vector<uint32_t>& GetSsrcs() const;
@ -420,7 +420,6 @@ class WebRtcVideoChannel2 : public VideoMediaChannel, public webrtc::Transport {
void SetRecvParameters(const ChangedRecvParameters& recv_params);
void OnFrame(const webrtc::VideoFrame& frame) override;
bool SmoothsRenderedFrames() const override;
bool IsDefaultStream() const;
void SetSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink);
@ -461,8 +460,6 @@ class WebRtcVideoChannel2 : public VideoMediaChannel, public webrtc::Transport {
WebRtcVideoDecoderFactory* const external_decoder_factory_;
std::vector<AllocatedDecoder> allocated_decoders_;
const bool disable_prerenderer_smoothing_;
rtc::CriticalSection sink_lock_;
rtc::VideoSinkInterface<cricket::VideoFrame>* sink_ GUARDED_BY(sink_lock_);
int last_width_ GUARDED_BY(sink_lock_);

1
webrtc/test/DEPS
View File

@ -2,6 +2,7 @@ include_rules = [
"+webrtc/base",
"+webrtc/call",
"+webrtc/common_video",
"+webrtc/media/base",
"+webrtc/modules/audio_coding",
"+webrtc/modules/audio_device",
"+webrtc/modules/media_file",

6
webrtc/test/video_renderer.h
View File

@ -12,11 +12,13 @@
#include <stddef.h>
#include "webrtc/video_renderer.h"
#include "webrtc/media/base/videosinkinterface.h"
namespace webrtc {
class VideoFrame;
namespace test {
class VideoRenderer : public webrtc::VideoRenderer {
class VideoRenderer : public rtc::VideoSinkInterface<VideoFrame> {
public:
// Creates a platform-specific renderer if possible, or a null implementation
// if failing.

20
webrtc/video/end_to_end_tests.cc
View File

@ -159,7 +159,7 @@ TEST_F(EndToEndTest, RendersSingleDelayedFrame) {
// frames in the queue.
static const int kDelayRenderCallbackMs = 1000;
class Renderer : public VideoRenderer {
class Renderer : public rtc::VideoSinkInterface<VideoFrame> {
public:
Renderer() : event_(false, false) {}
@ -222,7 +222,7 @@ TEST_F(EndToEndTest, RendersSingleDelayedFrame) {
}
TEST_F(EndToEndTest, TransmitsFirstFrame) {
class Renderer : public VideoRenderer {
class Renderer : public rtc::VideoSinkInterface<VideoFrame> {
public:
Renderer() : event_(false, false) {}
@ -266,7 +266,8 @@ TEST_F(EndToEndTest, TransmitsFirstFrame) {
}
TEST_F(EndToEndTest, SendsAndReceivesVP9) {
class VP9Observer : public test::EndToEndTest, public VideoRenderer {
class VP9Observer : public test::EndToEndTest,
public rtc::VideoSinkInterface<VideoFrame> {
public:
VP9Observer()
: EndToEndTest(2 * kDefaultTimeoutMs),
@ -317,7 +318,8 @@ TEST_F(EndToEndTest, SendsAndReceivesVP9) {
#if defined(WEBRTC_END_TO_END_H264_TESTS)
TEST_F(EndToEndTest, SendsAndReceivesH264) {
class H264Observer : public test::EndToEndTest, public VideoRenderer {
class H264Observer : public test::EndToEndTest,
public rtc::VideoSinkInterface<VideoFrame> {
public:
H264Observer()
: EndToEndTest(2 * kDefaultTimeoutMs),
@ -488,7 +490,8 @@ TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
}
TEST_F(EndToEndTest, CanReceiveFec) {
class FecRenderObserver : public test::EndToEndTest, public VideoRenderer {
class FecRenderObserver : public test::EndToEndTest,
public rtc::VideoSinkInterface<VideoFrame> {
public:
FecRenderObserver()
: EndToEndTest(kDefaultTimeoutMs), state_(kFirstPacket) {}
@ -864,7 +867,7 @@ TEST_F(EndToEndTest, UsesFrameCallbacks) {
static const int kWidth = 320;
static const int kHeight = 240;
class Renderer : public VideoRenderer {
class Renderer : public rtc::VideoSinkInterface<VideoFrame> {
public:
Renderer() : event_(false, false) {}
@ -964,7 +967,8 @@ TEST_F(EndToEndTest, UsesFrameCallbacks) {
void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
static const int kPacketsToDrop = 1;
class PliObserver : public test::EndToEndTest, public VideoRenderer {
class PliObserver : public test::EndToEndTest,
public rtc::VideoSinkInterface<VideoFrame> {
public:
explicit PliObserver(int rtp_history_ms)
: EndToEndTest(kLongTimeoutMs),
@ -1325,7 +1329,7 @@ class MultiStreamTest {
// Each renderer verifies that it receives the expected resolution, and as soon
// as every renderer has received a frame, the test finishes.
TEST_F(EndToEndTest, SendsAndReceivesMultipleStreams) {
class VideoOutputObserver : public VideoRenderer {
class VideoOutputObserver : public rtc::VideoSinkInterface<VideoFrame> {
public:
VideoOutputObserver(const MultiStreamTest::CodecSettings& settings,
uint32_t ssrc,

1
webrtc/video/receive_statistics_proxy.h
View File

@ -24,7 +24,6 @@
#include "webrtc/video/report_block_stats.h"
#include "webrtc/video/vie_channel.h"
#include "webrtc/video_receive_stream.h"
#include "webrtc/video_renderer.h"
namespace webrtc {

7
webrtc/video/replay.cc
View File

@ -136,9 +136,10 @@ static std::string Codec() { return static_cast<std::string>(FLAGS_codec); }
static const uint32_t kReceiverLocalSsrc = 0x123456;
class FileRenderPassthrough : public VideoRenderer {
class FileRenderPassthrough : public rtc::VideoSinkInterface<VideoFrame> {
public:
FileRenderPassthrough(const std::string& basename, VideoRenderer* renderer)
FileRenderPassthrough(const std::string& basename,
rtc::VideoSinkInterface<VideoFrame>* renderer)
: basename_(basename),
renderer_(renderer),
file_(nullptr),
@ -182,7 +183,7 @@ class FileRenderPassthrough : public VideoRenderer {
}
const std::string basename_;
VideoRenderer* const renderer_;
rtc::VideoSinkInterface<VideoFrame>* const renderer_;
FILE* file_;
size_t count_;
int last_width_;

9
webrtc/video/video_capture_input.cc
View File

@ -24,10 +24,11 @@
namespace webrtc {
namespace internal {
VideoCaptureInput::VideoCaptureInput(rtc::Event* capture_event,
VideoRenderer* local_renderer,
SendStatisticsProxy* stats_proxy,
OveruseFrameDetector* overuse_detector)
VideoCaptureInput::VideoCaptureInput(
rtc::Event* capture_event,
rtc::VideoSinkInterface<VideoFrame>* local_renderer,
SendStatisticsProxy* stats_proxy,
OveruseFrameDetector* overuse_detector)
: local_renderer_(local_renderer),
stats_proxy_(stats_proxy),
capture_event_(capture_event),

5
webrtc/video/video_capture_input.h
View File

@ -32,13 +32,12 @@ namespace webrtc {
class Config;
class OveruseFrameDetector;
class SendStatisticsProxy;
class VideoRenderer;
namespace internal {
class VideoCaptureInput : public webrtc::VideoCaptureInput {
public:
VideoCaptureInput(rtc::Event* capture_event,
VideoRenderer* local_renderer,
rtc::VideoSinkInterface<VideoFrame>* local_renderer,
SendStatisticsProxy* send_stats_proxy,
OveruseFrameDetector* overuse_detector);
~VideoCaptureInput();
@ -50,7 +49,7 @@ class VideoCaptureInput : public webrtc::VideoCaptureInput {
private:
rtc::CriticalSection crit_;
VideoRenderer* const local_renderer_;
rtc::VideoSinkInterface<VideoFrame>* const local_renderer_;
SendStatisticsProxy* const stats_proxy_;
rtc::Event* const capture_event_;

2
webrtc/video/video_quality_test.cc
View File

@ -43,7 +43,7 @@ static const int kPayloadTypeVP9 = 124;
class VideoAnalyzer : public PacketReceiver,
public Transport,
public VideoRenderer,
public rtc::VideoSinkInterface<VideoFrame>,
public VideoCaptureInput,
public EncodedFrameObserver {
public:

4
webrtc/video/video_receive_stream.cc
View File

@ -164,9 +164,7 @@ VideoReceiveStream::VideoReceiveStream(
nullptr,
this,
this)),
incoming_video_stream_(
0,
config.renderer ? config.renderer->SmoothsRenderedFrames() : false),
incoming_video_stream_(0, config.disable_prerenderer_smoothing),
stats_proxy_(config_, clock_),
vie_channel_(&transport_adapter_,
process_thread,

8
webrtc/video_receive_stream.h
View File

@ -21,7 +21,7 @@
#include "webrtc/frame_callback.h"
#include "webrtc/stream.h"
#include "webrtc/transport.h"
#include "webrtc/video_renderer.h"
#include "webrtc/media/base/videosinkinterface.h"
namespace webrtc {
@ -145,13 +145,17 @@ class VideoReceiveStream : public ReceiveStream {
// VideoRenderer will be called for each decoded frame. 'nullptr' disables
// rendering of this stream.
VideoRenderer* renderer = nullptr;
rtc::VideoSinkInterface<VideoFrame>* renderer = nullptr;
// Expected delay needed by the renderer, i.e. the frame will be delivered
// this many milliseconds, if possible, earlier than the ideal render time.
// Only valid if 'renderer' is set.
int render_delay_ms = 10;
// If set, pass frames on to the renderer as soon as they are
// available.
bool disable_prerenderer_smoothing = false;
// Identifier for an A/V synchronization group. Empty string to disable.
// TODO(pbos): Synchronize streams in a sync group, not just video streams
// to one of the audio streams.

32
webrtc/video_renderer.h
View File

@ -1,32 +0,0 @@
/*
* Copyright (c) 2013 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.
*/
#ifndef WEBRTC_VIDEO_RENDERER_H_
#define WEBRTC_VIDEO_RENDERER_H_
#include "webrtc/media/base/videosinkinterface.h"
namespace webrtc {
class VideoFrame;
class VideoRenderer : public rtc::VideoSinkInterface<VideoFrame> {
public:
// This function returns true if WebRTC should not delay frames for
// smoothness. In general, this case means the renderer can schedule frames to
// optimize smoothness.
virtual bool SmoothsRenderedFrames() const { return false; }
protected:
virtual ~VideoRenderer() {}
};
} // namespace webrtc
#endif // WEBRTC_VIDEO_RENDERER_H_

4
webrtc/video_send_stream.h
View File

@ -19,7 +19,7 @@
#include "webrtc/frame_callback.h"
#include "webrtc/stream.h"
#include "webrtc/transport.h"
#include "webrtc/video_renderer.h"
#include "webrtc/media/base/videosinkinterface.h"
namespace webrtc {
@ -149,7 +149,7 @@ class VideoSendStream : public SendStream {
// Renderer for local preview. The local renderer will be called even if
// sending hasn't started. 'nullptr' disables local rendering.
VideoRenderer* local_renderer = nullptr;
rtc::VideoSinkInterface<VideoFrame>* local_renderer = nullptr;
// Expected delay needed by the renderer, i.e. the frame will be delivered
// this many milliseconds, if possible, earlier than expected render time.

1
webrtc/webrtc.gyp
View File

@ -116,7 +116,6 @@
'stream.h',
'transport.h',
'video_receive_stream.h',
'video_renderer.h',
'video_send_stream.h',
'<@(webrtc_audio_sources)',