Deletes the class VideoRendererCallback.

webrtc/modules/video_render/test/testAPI/testAPI.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
@@ skipping 230 matching lines @@
 
     *outWindow = _window;
     *outDisplay = _display;
 
     return 0;
 }
 #endif  // WEBRTC_LINUX
 
 // Note: Mac code is in testApi_mac.mm.
 
-class MyRenderCallback: public VideoRenderCallback
+class MyRenderCallback: public rtc::VideoSinkInterface<VideoFrame>
 {
 public:
     MyRenderCallback() :
         _cnt(0)
     {
     }
     ;
     ~MyRenderCallback()
     {
     }
     ;
-    virtual int32_t RenderFrame(const uint32_t streamId,
-                                const VideoFrame& videoFrame) {
+    void OnFrame(const VideoFrame& videoFrame) override {
         _cnt++;
         if (_cnt % 100 == 0)
         {
             printf("Render callback %d \n",_cnt);
         }
-        return 0;
     }
     int32_t _cnt;
 };
 
 void GetTestVideoFrame(VideoFrame* frame, uint8_t startColor) {
     // changing color
     static uint8_t color = startColor;
 
     memset(frame->buffer(kYPlane), color, frame->allocated_size(kYPlane));
     memset(frame->buffer(kUPlane), color, frame->allocated_size(kUPlane));
     memset(frame->buffer(kVPlane), color, frame->allocated_size(kVPlane));
 
     ++color;
 }
 
 int TestSingleStream(VideoRender* renderModule) {
     int error = 0;
     // Add settings for a stream to render
     printf("Add stream 0 to entire window\n");
     const int streamId0 = 0;
-    VideoRenderCallback* renderCallback0 = renderModule->AddIncomingRenderStream(streamId0, 0, 0.0f, 0.0f, 1.0f, 1.0f);
+    rtc::VideoSinkInterface<VideoFrame>* renderCallback0 =
+      renderModule->AddIncomingRenderStream(
+          streamId0, 0, 0.0f, 0.0f, 1.0f, 1.0f);
     assert(renderCallback0 != NULL);
 
     printf("Start render\n");
     error = renderModule->StartRender(streamId0);
     if (error != 0) {
       // TODO(phoglund): This test will not work if compiled in release mode.
       // This rather silly construct here is to avoid compilation errors when
       // compiling in release. Release => no asserts => unused 'error' variable.
       assert(false);
     }
 
     // Loop through an I420 file and render each frame
     const int width = 352;
     const int half_width = (width + 1) / 2;
     const int height = 288;
 
     VideoFrame videoFrame0;
     videoFrame0.CreateEmptyFrame(width, height, width, half_width, half_width);
 
     const uint32_t renderDelayMs = 500;
 
     for (int i=0; i<TEST_FRAME_NUM; i++) {
         GetTestVideoFrame(&videoFrame0, TEST_STREAM0_START_COLOR);
         // Render this frame with the specified delay
         videoFrame0.set_render_time_ms(TickTime::MillisecondTimestamp()
                                        + renderDelayMs);
-        renderCallback0->RenderFrame(streamId0, videoFrame0);
+        renderCallback0->OnFrame(videoFrame0);
         SleepMs(1000/TEST_FRAME_RATE);
     }
 
 
     // Shut down
     printf("Closing...\n");
     error = renderModule->StopRender(streamId0);
     assert(error == 0);
 
     error = renderModule->DeleteIncomingRenderStream(streamId0);
@@ skipping 16 matching lines @@
     return 0;
 }
 
 int TestBitmapText(VideoRender* renderModule) {
 #if defined(WIN32)
 
     int error = 0;
     // Add settings for a stream to render
     printf("Add stream 0 to entire window\n");
     const int streamId0 = 0;
-    VideoRenderCallback* renderCallback0 = renderModule->AddIncomingRenderStream(streamId0, 0, 0.0f, 0.0f, 1.0f, 1.0f);
+    rtc::VideoSinkInterface<VideoFrame>* renderCallback0 =
+        renderModule->AddIncomingRenderStream(
+            streamId0, 0, 0.0f, 0.0f, 1.0f, 1.0f);
     assert(renderCallback0 != NULL);
 
     printf("Adding Bitmap\n");
     DDCOLORKEY ColorKey; // black
     ColorKey.dwColorSpaceHighValue = RGB(0, 0, 0);
     ColorKey.dwColorSpaceLowValue = RGB(0, 0, 0);
     HBITMAP hbm = (HBITMAP)LoadImage(NULL,
                                      (LPCTSTR)_T("renderStartImage.bmp"),
                                      IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
     renderModule->SetBitmap(hbm, 0, &ColorKey, 0.0f, 0.0f, 0.3f,
@@ skipping 16 matching lines @@
     VideoFrame videoFrame0;
     videoFrame0.CreateEmptyFrame(width, height, width, half_width, half_width);
 
     const uint32_t renderDelayMs = 500;
 
     for (int i=0; i<TEST_FRAME_NUM; i++) {
         GetTestVideoFrame(&videoFrame0, TEST_STREAM0_START_COLOR);
         // Render this frame with the specified delay
         videoFrame0.set_render_time_ms(TickTime::MillisecondTimestamp() +
                                        renderDelayMs);
-        renderCallback0->RenderFrame(streamId0, videoFrame0);
+        renderCallback0->OnFrame(videoFrame0);
         SleepMs(1000/TEST_FRAME_RATE);
     }
     // Sleep and let all frames be rendered before closing
     SleepMs(renderDelayMs*2);
 
 
     // Shut down
     printf("Closing...\n");
     ColorKey.dwColorSpaceHighValue = RGB(0,0,0);
     ColorKey.dwColorSpaceLowValue = RGB(0,0,0);
@@ skipping 10 matching lines @@
 
     return 0;
 }
 
 int TestMultipleStreams(VideoRender* renderModule) {
     int error = 0;
 
     // Add settings for a stream to render
     printf("Add stream 0\n");
     const int streamId0 = 0;
-    VideoRenderCallback* renderCallback0 =
-        renderModule->AddIncomingRenderStream(streamId0, 0, 0.0f, 0.0f, 0.45f, 0.45f);
+    rtc::VideoSinkInterface<VideoFrame>* renderCallback0 =
+        renderModule->AddIncomingRenderStream(
+            streamId0, 0, 0.0f, 0.0f, 0.45f, 0.45f);
     assert(renderCallback0 != NULL);
     printf("Add stream 1\n");
     const int streamId1 = 1;
-    VideoRenderCallback* renderCallback1 =
-        renderModule->AddIncomingRenderStream(streamId1, 0, 0.55f, 0.0f, 1.0f, 0.45f);
+    rtc::VideoSinkInterface<VideoFrame>* renderCallback1 =
+        renderModule->AddIncomingRenderStream(
+            streamId1, 0, 0.55f, 0.0f, 1.0f, 0.45f);
     assert(renderCallback1 != NULL);
     printf("Add stream 2\n");
     const int streamId2 = 2;
-    VideoRenderCallback* renderCallback2 =
-        renderModule->AddIncomingRenderStream(streamId2, 0, 0.0f, 0.55f, 0.45f, 1.0f);
+    rtc::VideoSinkInterface<VideoFrame>* renderCallback2 =
+        renderModule->AddIncomingRenderStream(
+            streamId2, 0, 0.0f, 0.55f, 0.45f, 1.0f);
     assert(renderCallback2 != NULL);
     printf("Add stream 3\n");
     const int streamId3 = 3;
-    VideoRenderCallback* renderCallback3 =
-        renderModule->AddIncomingRenderStream(streamId3, 0, 0.55f, 0.55f, 1.0f, 1.0f);
+    rtc::VideoSinkInterface<VideoFrame>* renderCallback3 =
+        renderModule->AddIncomingRenderStream(
+            streamId3, 0, 0.55f, 0.55f, 1.0f, 1.0f);
     assert(renderCallback3 != NULL);
     error = renderModule->StartRender(streamId0);
     if (error != 0) {
       // TODO(phoglund): This test will not work if compiled in release mode.
       // This rather silly construct here is to avoid compilation errors when
       // compiling in release. Release => no asserts => unused 'error' variable.
       assert(false);
     }
     error = renderModule->StartRender(streamId1);
     assert(error == 0);
@@ skipping 17 matching lines @@
     videoFrame3.CreateEmptyFrame(width, height, width, half_width, half_width);
 
     const uint32_t renderDelayMs = 500;
 
     // Render frames with the specified delay.
     for (int i=0; i<TEST_FRAME_NUM; i++) {
       GetTestVideoFrame(&videoFrame0, TEST_STREAM0_START_COLOR);
 
       videoFrame0.set_render_time_ms(TickTime::MillisecondTimestamp() +
                                      renderDelayMs);
-      renderCallback0->RenderFrame(streamId0, videoFrame0);
+      renderCallback0->OnFrame(videoFrame0);
 
       GetTestVideoFrame(&videoFrame1, TEST_STREAM1_START_COLOR);
       videoFrame1.set_render_time_ms(TickTime::MillisecondTimestamp() +
                                      renderDelayMs);
-      renderCallback1->RenderFrame(streamId1, videoFrame1);
+      renderCallback1->OnFrame(videoFrame1);
 
       GetTestVideoFrame(&videoFrame2,  TEST_STREAM2_START_COLOR);
       videoFrame2.set_render_time_ms(TickTime::MillisecondTimestamp() +
                                      renderDelayMs);
-      renderCallback2->RenderFrame(streamId2, videoFrame2);
+      renderCallback2->OnFrame(videoFrame2);
 
       GetTestVideoFrame(&videoFrame3, TEST_STREAM3_START_COLOR);
       videoFrame3.set_render_time_ms(TickTime::MillisecondTimestamp() +
                                      renderDelayMs);
-      renderCallback3->RenderFrame(streamId3, videoFrame3);
+      renderCallback3->OnFrame(videoFrame3);
 
       SleepMs(1000/TEST_FRAME_RATE);
     }
 
     // Shut down
     printf("Closing...\n");
     error = renderModule->StopRender(streamId0);
     assert(error == 0);
     error = renderModule->DeleteIncomingRenderStream(streamId0);
     assert(error == 0);
@@ skipping 11 matching lines @@
     assert(error == 0);
 
     return 0;
 }
 
 int TestExternalRender(VideoRender* renderModule) {
     int error = 0;
     MyRenderCallback *externalRender = new MyRenderCallback();
 
     const int streamId0 = 0;
-    VideoRenderCallback* renderCallback0 =
+    rtc::VideoSinkInterface<VideoFrame>* renderCallback0 =
         renderModule->AddIncomingRenderStream(streamId0, 0, 0.0f, 0.0f,
                                                    1.0f, 1.0f);
     assert(renderCallback0 != NULL);
     error = renderModule->AddExternalRenderCallback(streamId0, externalRender);
     if (error != 0) {
       // TODO(phoglund): This test will not work if compiled in release mode.
       // This rather silly construct here is to avoid compilation errors when
       // compiling in release. Release => no asserts => unused 'error' variable.
       assert(false);
     }
 
     error = renderModule->StartRender(streamId0);
     assert(error == 0);
 
     const int width = 352;
     const int half_width = (width + 1) / 2;
     const int height = 288;
     VideoFrame videoFrame0;
     videoFrame0.CreateEmptyFrame(width, height, width, half_width, half_width);
 
     const uint32_t renderDelayMs = 500;
     int frameCount = TEST_FRAME_NUM;
     for (int i=0; i<frameCount; i++) {
         videoFrame0.set_render_time_ms(TickTime::MillisecondTimestamp() +
                                        renderDelayMs);
-        renderCallback0->RenderFrame(streamId0, videoFrame0);
+        renderCallback0->OnFrame(videoFrame0);
         SleepMs(33);
     }
 
     // Sleep and let all frames be rendered before closing
     SleepMs(2*renderDelayMs);
 
     // Shut down
     printf("Closing...\n");
     error = renderModule->StopRender(streamId0);
     assert(error == 0);
@@ skipping 75 matching lines @@
     Display* display;
     WebRtcCreateWindow(&testWindow, &display, 0, 352, 288);
     VideoRenderType windowType = kRenderX11;
     window = (void*)testWindow;
 #endif // WEBRTC_LINUX
 
     RunVideoRenderTests(window, windowType);
     return 0;
 }
 #endif  // !WEBRTC_MAC