This cl deletes the class webrtc::VideoRendererCallback.

Replaced by VideoSinkInterface instead.

Also delete stream_id property of IncomingVideoStream.

BUG=webrtc:5426

Review-Url: https://codereview.webrtc.org/1813173002
Cr-Commit-Position: refs/heads/master@{#12602}

webrtc/common_video/DEPS

@@ -1,4 +1,5 @@
 include_rules = [
   "+webrtc/base",
+  "+webrtc/media/base",
   "+webrtc/system_wrappers",
 ]

webrtc/common_video/include/incoming_video_stream.h

@@ -17,34 +17,25 @@
 #include "webrtc/base/platform_thread.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/common_video/video_render_frames.h"
+#include "webrtc/media/base/videosinkinterface.h"
 
 namespace webrtc {
 class EventTimerWrapper;
 
-class VideoRenderCallback {
- public:
-  virtual int32_t RenderFrame(const uint32_t streamId,
-                              const VideoFrame& videoFrame) = 0;
 
- protected:
-  virtual ~VideoRenderCallback() {}
-};
-
-class IncomingVideoStream : public VideoRenderCallback {
+class IncomingVideoStream : public rtc::VideoSinkInterface<VideoFrame> {
  public:
-  IncomingVideoStream(uint32_t stream_id, bool disable_prerenderer_smoothing);
+  explicit IncomingVideoStream(bool disable_prerenderer_smoothing);
   ~IncomingVideoStream();
 
-  // Get callback to deliver frames to the module.
-  VideoRenderCallback* ModuleCallback();
-  virtual int32_t RenderFrame(const uint32_t stream_id,
-                              const VideoFrame& video_frame);
+  // Overrides VideoSinkInterface
+  void OnFrame(const VideoFrame& video_frame) override;
 
   // Set callback to the platform dependent code.
-  void SetRenderCallback(VideoRenderCallback* render_callback);
+  void SetRenderCallback(rtc::VideoSinkInterface<VideoFrame>* render_callback);
 
   // Callback for file recording, snapshot, ...
-  void SetExternalCallback(VideoRenderCallback* render_object);
+  void SetExternalCallback(rtc::VideoSinkInterface<VideoFrame>* render_object);
 
   // Start/Stop.
   int32_t Start();
@@ -54,7 +45,6 @@ class IncomingVideoStream : public VideoRenderCallback {
   int32_t Reset();
 
   // Properties.
-  uint32_t StreamId() const;
   uint32_t IncomingRate() const;
 
   int32_t SetExpectedRenderDelay(int32_t delay_ms);
@@ -70,7 +60,6 @@ class IncomingVideoStream : public VideoRenderCallback {
 
   void DeliverFrame(const VideoFrame& video_frame);
 
-  uint32_t const stream_id_;
   const bool disable_prerenderer_smoothing_;
   // Critsects in allowed to enter order.
   rtc::CriticalSection stream_critsect_;
@@ -83,8 +72,10 @@ class IncomingVideoStream : public VideoRenderCallback {
   std::unique_ptr<EventTimerWrapper> deliver_buffer_event_;
 
   bool running_ GUARDED_BY(stream_critsect_);
-  VideoRenderCallback* external_callback_ GUARDED_BY(thread_critsect_);
-  VideoRenderCallback* render_callback_ GUARDED_BY(thread_critsect_);
+  rtc::VideoSinkInterface<VideoFrame>* external_callback_
+      GUARDED_BY(thread_critsect_);
+  rtc::VideoSinkInterface<VideoFrame>* render_callback_
+      GUARDED_BY(thread_critsect_);
   const std::unique_ptr<VideoRenderFrames> render_buffers_
       GUARDED_BY(buffer_critsect_);
 

webrtc/common_video/incoming_video_stream.cc

@@ -31,10 +31,8 @@
 
 namespace webrtc {
 
-IncomingVideoStream::IncomingVideoStream(uint32_t stream_id,
-                                         bool disable_prerenderer_smoothing)
-    : stream_id_(stream_id),
-      disable_prerenderer_smoothing_(disable_prerenderer_smoothing),
+IncomingVideoStream::IncomingVideoStream(bool disable_prerenderer_smoothing)
+    : disable_prerenderer_smoothing_(disable_prerenderer_smoothing),
       incoming_render_thread_(),
       deliver_buffer_event_(EventTimerWrapper::Create()),
       running_(false),
@@ -49,16 +47,11 @@ IncomingVideoStream::~IncomingVideoStream() {
   Stop();
 }
 
-VideoRenderCallback* IncomingVideoStream::ModuleCallback() {
-  return this;
-}
-
-int32_t IncomingVideoStream::RenderFrame(const uint32_t stream_id,
-                                         const VideoFrame& video_frame) {
+void IncomingVideoStream::OnFrame(const VideoFrame& video_frame) {
   rtc::CritScope csS(&stream_critsect_);
 
   if (!running_) {
-    return -1;
+    return;
   }
 
   // Rate statistics.
@@ -81,11 +74,10 @@ int32_t IncomingVideoStream::RenderFrame(const uint32_t stream_id,
       deliver_buffer_event_->Set();
     }
   }
-  return 0;
 }
 
 void IncomingVideoStream::SetRenderCallback(
-    VideoRenderCallback* render_callback) {
+    rtc::VideoSinkInterface<VideoFrame>* render_callback) {
   rtc::CritScope cs(&thread_critsect_);
   render_callback_ = render_callback;
 }
@@ -101,7 +93,7 @@ int32_t IncomingVideoStream::SetExpectedRenderDelay(
 }
 
 void IncomingVideoStream::SetExternalCallback(
-    VideoRenderCallback* external_callback) {
+    rtc::VideoSinkInterface<VideoFrame>* external_callback) {
   rtc::CritScope cs(&thread_critsect_);
   external_callback_ = external_callback;
 }
@@ -165,10 +157,6 @@ int32_t IncomingVideoStream::Reset() {
   return 0;
 }
 
-uint32_t IncomingVideoStream::StreamId() const {
-  return stream_id_;
-}
-
 uint32_t IncomingVideoStream::IncomingRate() const {
   rtc::CritScope cs(&stream_critsect_);
   return incoming_rate_;
@@ -215,9 +203,9 @@ void IncomingVideoStream::DeliverFrame(const VideoFrame& video_frame) {
 
   // Send frame for rendering.
   if (external_callback_) {
-    external_callback_->RenderFrame(stream_id_, video_frame);
+    external_callback_->OnFrame(video_frame);
   } else if (render_callback_) {
-    render_callback_->RenderFrame(stream_id_, video_frame);
+    render_callback_->OnFrame(video_frame);
   }
 }
 

webrtc/video/video_receive_stream.cc

@@ -163,7 +163,7 @@ VideoReceiveStream::VideoReceiveStream(
       call_stats_(call_stats),
       remb_(remb),
       video_receiver_(clock_, nullptr, this, this, this),
-      incoming_video_stream_(0, config.disable_prerenderer_smoothing),
+      incoming_video_stream_(config.disable_prerenderer_smoothing),
       stats_proxy_(config_, clock_),
       rtp_stream_receiver_(&video_receiver_,
                            congestion_controller_->GetRemoteBitrateEstimator(
@@ -384,8 +384,7 @@ void VideoReceiveStream::FrameCallback(VideoFrame* video_frame) {
   }
 }
 
-int VideoReceiveStream::RenderFrame(const uint32_t /*stream_id*/,
-                                    const VideoFrame& video_frame) {
+void VideoReceiveStream::OnFrame(const VideoFrame& video_frame) {
   int64_t sync_offset_ms;
   if (vie_sync_.GetStreamSyncOffsetInMs(video_frame, &sync_offset_ms))
     stats_proxy_.OnSyncOffsetUpdated(sync_offset_ms);
@@ -394,8 +393,6 @@ int VideoReceiveStream::RenderFrame(const uint32_t /*stream_id*/,
     config_.renderer->OnFrame(video_frame);
 
   stats_proxy_.OnRenderedFrame(video_frame.width(), video_frame.height());
-
-  return 0;
 }
 
 // TODO(asapersson): Consider moving callback from video_encoder.h or

webrtc/video/video_receive_stream.h

@@ -40,7 +40,7 @@ namespace internal {
 
 class VideoReceiveStream : public webrtc::VideoReceiveStream,
                            public I420FrameCallback,
-                           public VideoRenderCallback,
+                           public rtc::VideoSinkInterface<VideoFrame>,
                            public EncodedImageCallback,
                            public NackSender,
                            public KeyFrameRequestSender {
@@ -69,9 +69,8 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream,
   // Overrides I420FrameCallback.
   void FrameCallback(VideoFrame* video_frame) override;
 
-  // Overrides VideoRenderCallback.
-  int RenderFrame(const uint32_t /*stream_id*/,
-                  const VideoFrame& video_frame) override;
+  // Overrides rtc::VideoSinkInterface<VideoFrame>.
+  void OnFrame(const VideoFrame& video_frame) override;
 
   // Overrides EncodedImageCallback.
   int32_t Encoded(const EncodedImage& encoded_image,

webrtc/video/vie_channel.cc

@@ -169,8 +169,7 @@ int32_t ViEChannel::FrameToRender(VideoFrame& video_frame) {  // NOLINT
   if (pre_render_callback_)
     pre_render_callback_->FrameCallback(&video_frame);
 
-  // TODO(pbos): Remove stream id argument.
-  incoming_video_stream_->RenderFrame(0xFFFFFFFF, video_frame);
+  incoming_video_stream_->OnFrame(video_frame);
   return 0;
 }
 

webrtc/video/vie_channel.h

@@ -42,7 +42,6 @@ class PayloadRouter;
 class ReceiveStatisticsProxy;
 class RtcpRttStats;
 class ViERTPObserver;
-class VideoRenderCallback;
 class VoEVideoSync;
 
 namespace vcm {