Delete method webrtc::VideoFrame::native_handle.

webrtc/video/video_capture_input_unittest.cc

 /*
  *  Copyright (c) 2014 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_capture_input.h"
 
 #include <memory>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/event.h"
 #include "webrtc/base/refcount.h"
 #include "webrtc/test/fake_texture_frame.h"
+#include "webrtc/test/frame_utils.h"
 #include "webrtc/video/send_statistics_proxy.h"
 
 // If an output frame does not arrive in 500ms, the test will fail.
 #define FRAME_TIMEOUT_MS 500
 
 namespace webrtc {
 
-bool EqualFrames(const VideoFrame& frame1, const VideoFrame& frame2);
-bool EqualTextureFrames(const VideoFrame& frame1, const VideoFrame& frame2);
-bool EqualBufferFrames(const VideoFrame& frame1, const VideoFrame& frame2);
 bool EqualFramesVector(const std::vector<std::unique_ptr<VideoFrame>>& frames1,
                        const std::vector<std::unique_ptr<VideoFrame>>& frames2);
 std::unique_ptr<VideoFrame> CreateVideoFrame(uint8_t length);
 
 class VideoCaptureInputTest : public ::testing::Test {
  protected:
   VideoCaptureInputTest()
       : stats_proxy_(Clock::GetRealTimeClock(),
                      webrtc::VideoSendStream::Config(nullptr),
                      webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo),
         capture_event_(false, false) {}
 
   virtual void SetUp() {
     overuse_detector_.reset(
         new OveruseFrameDetector(Clock::GetRealTimeClock(), CpuOveruseOptions(),
                                  nullptr, nullptr, &stats_proxy_));
     input_.reset(new internal::VideoCaptureInput(
         &capture_event_, nullptr, &stats_proxy_, overuse_detector_.get()));
   }
 
   void AddInputFrame(VideoFrame* frame) {
     input_->IncomingCapturedFrame(*frame);
   }
 
   void WaitOutputFrame() {
     EXPECT_TRUE(capture_event_.Wait(FRAME_TIMEOUT_MS));
     VideoFrame frame;
     EXPECT_TRUE(input_->GetVideoFrame(&frame));
-    if (!frame.native_handle()) {
+    ASSERT_TRUE(frame.video_frame_buffer());
+    if (!frame.video_frame_buffer()->native_handle()) {
       output_frame_ybuffers_.push_back(
           static_cast<const VideoFrame*>(&frame)->buffer(kYPlane));
     }
     output_frames_.push_back(
         std::unique_ptr<VideoFrame>(new VideoFrame(frame)));
   }
 
   SendStatisticsProxy stats_proxy_;
 
   rtc::Event capture_event_;
@@ skipping 93 matching lines @@
 TEST_F(VideoCaptureInputTest, TestTextureFrames) {
   const int kNumFrame = 3;
   for (int i = 0 ; i < kNumFrame; ++i) {
     test::FakeNativeHandle* dummy_handle = new test::FakeNativeHandle();
     // Add one to |i| so that width/height > 0.
     input_frames_.push_back(std::unique_ptr<VideoFrame>(new VideoFrame(
         test::FakeNativeHandle::CreateFrame(dummy_handle, i + 1, i + 1, i + 1,
                                             i + 1, webrtc::kVideoRotation_0))));
     AddInputFrame(input_frames_[i].get());
     WaitOutputFrame();
-    EXPECT_EQ(dummy_handle, output_frames_[i]->native_handle());
+    ASSERT_TRUE(output_frames_[i]->video_frame_buffer());
+    EXPECT_EQ(dummy_handle,
+              output_frames_[i]->video_frame_buffer()->native_handle());
   }
 
   EXPECT_TRUE(EqualFramesVector(input_frames_, output_frames_));
 }
 
 TEST_F(VideoCaptureInputTest, TestI420Frames) {
   const int kNumFrame = 4;
   std::vector<const uint8_t*> ybuffer_pointers;
   for (int i = 0; i < kNumFrame; ++i) {
     input_frames_.push_back(CreateVideoFrame(static_cast<uint8_t>(i + 1)));
     const VideoFrame* const_input_frame = input_frames_[i].get();
     ybuffer_pointers.push_back(const_input_frame->buffer(kYPlane));
     AddInputFrame(input_frames_[i].get());
     WaitOutputFrame();
   }
 
   EXPECT_TRUE(EqualFramesVector(input_frames_, output_frames_));
   // Make sure the buffer is not copied.
   for (int i = 0; i < kNumFrame; ++i)
     EXPECT_EQ(ybuffer_pointers[i], output_frame_ybuffers_[i]);
 }
 
 TEST_F(VideoCaptureInputTest, TestI420FrameAfterTextureFrame) {
   test::FakeNativeHandle* dummy_handle = new test::FakeNativeHandle();
   input_frames_.push_back(std::unique_ptr<VideoFrame>(
       new VideoFrame(test::FakeNativeHandle::CreateFrame(
           dummy_handle, 1, 1, 1, 1, webrtc::kVideoRotation_0))));
   AddInputFrame(input_frames_[0].get());
   WaitOutputFrame();
-  EXPECT_EQ(dummy_handle, output_frames_[0]->native_handle());
+  ASSERT_TRUE(output_frames_[0]->video_frame_buffer());
+  EXPECT_EQ(dummy_handle,
+            output_frames_[0]->video_frame_buffer()->native_handle());
 
   input_frames_.push_back(CreateVideoFrame(2));
   AddInputFrame(input_frames_[1].get());
   WaitOutputFrame();
 
   EXPECT_TRUE(EqualFramesVector(input_frames_, output_frames_));
 }
 
 TEST_F(VideoCaptureInputTest, TestTextureFrameAfterI420Frame) {
   input_frames_.push_back(CreateVideoFrame(1));
   AddInputFrame(input_frames_[0].get());
   WaitOutputFrame();
 
   test::FakeNativeHandle* dummy_handle = new test::FakeNativeHandle();
   input_frames_.push_back(std::unique_ptr<VideoFrame>(
       new VideoFrame(test::FakeNativeHandle::CreateFrame(
           dummy_handle, 1, 1, 2, 2, webrtc::kVideoRotation_0))));
   AddInputFrame(input_frames_[1].get());
   WaitOutputFrame();
 
   EXPECT_TRUE(EqualFramesVector(input_frames_, output_frames_));
 }
 
-bool EqualFrames(const VideoFrame& frame1, const VideoFrame& frame2) {
-  if (frame1.native_handle() || frame2.native_handle())
-    return EqualTextureFrames(frame1, frame2);
-  return EqualBufferFrames(frame1, frame2);
-}
-
-bool EqualTextureFrames(const VideoFrame& frame1, const VideoFrame& frame2) {
-  return ((frame1.native_handle() == frame2.native_handle()) &&
-          (frame1.width() == frame2.width()) &&
-          (frame1.height() == frame2.height()));
-}
-
-bool EqualBufferFrames(const VideoFrame& frame1, const VideoFrame& frame2) {
-  return ((frame1.width() == frame2.width()) &&
-          (frame1.height() == frame2.height()) &&
-          (frame1.stride(kYPlane) == frame2.stride(kYPlane)) &&
-          (frame1.stride(kUPlane) == frame2.stride(kUPlane)) &&
-          (frame1.stride(kVPlane) == frame2.stride(kVPlane)) &&
-          (frame1.allocated_size(kYPlane) == frame2.allocated_size(kYPlane)) &&
-          (frame1.allocated_size(kUPlane) == frame2.allocated_size(kUPlane)) &&
-          (frame1.allocated_size(kVPlane) == frame2.allocated_size(kVPlane)) &&
-          (memcmp(frame1.buffer(kYPlane), frame2.buffer(kYPlane),
-                  frame1.allocated_size(kYPlane)) == 0) &&
-          (memcmp(frame1.buffer(kUPlane), frame2.buffer(kUPlane),
-                  frame1.allocated_size(kUPlane)) == 0) &&
-          (memcmp(frame1.buffer(kVPlane), frame2.buffer(kVPlane),
-                  frame1.allocated_size(kVPlane)) == 0));
-}
-
 bool EqualFramesVector(
     const std::vector<std::unique_ptr<VideoFrame>>& frames1,
     const std::vector<std::unique_ptr<VideoFrame>>& frames2) {
   if (frames1.size() != frames2.size())
     return false;
   for (size_t i = 0; i < frames1.size(); ++i) {
-    if (!EqualFrames(*frames1[i], *frames2[i]))
+    // Compare frame buffers, since we don't care about differing timestamps.
+    if (!test::FrameBufsEqual(frames1[i]->video_frame_buffer(),
+                              frames2[i]->video_frame_buffer()))

[pbos-webrtc, 2016/04/14 14:50:54]

{}s

[nisse-webrtc, 2016/04/15 07:15:09]

Done.

       return false;
   }
   return true;
 }
 
 std::unique_ptr<VideoFrame> CreateVideoFrame(uint8_t data) {
   std::unique_ptr<VideoFrame> frame(new VideoFrame());
   const int width = 36;
   const int height = 24;
   const int kSizeY = width * height * 2;
   uint8_t buffer[kSizeY];
   memset(buffer, data, kSizeY);
   frame->CreateFrame(buffer, buffer, buffer, width, height, width, width / 2,
                      width / 2, kVideoRotation_0);
   frame->set_render_time_ms(data);
   return frame;
 }
 
 }  // namespace webrtc