Rewrote codec test to use fake camera.

Tests now fail more cleanly if the input video file is incorrect. Fixed some of the style issues in vie_autotest_codec.

Rewrote the automated standard codec test to use the new fake camera.

Started sketching on a new test case. Wrote a new abstraction called ViEFakeCamera which hides the details of how to thread a file capture device in the typical test case.

BUG=
TEST=

Review URL: http://webrtc-codereview.appspot.com/242008

git-svn-id: http://webrtc.googlecode.com/svn/trunk@815 4adac7df-926f-26a2-2b94-8c16560cd09d

Author: [email protected]

src/video_engine/main/test/AutoTest/automated/vie_standard_integration_test.cc

@@ -62,14 +62,17 @@ TEST_F(ViEStandardIntegrationTest, RunsBaseTestWithoutErrors)  {
                                        FLAGS_i420_test_video_height);
 }
 
+TEST_F(ViEStandardIntegrationTest, RunsCodecTestWithoutErrors)  {
+  tests_->ViEAutomatedCodecStandardTest(FLAGS_i420_test_video_path,
+                                        FLAGS_i420_test_video_width,
+                                        FLAGS_i420_test_video_height);
+}
+
 // These tests still require a physical camera:
 TEST_F(ViEStandardIntegrationTest, RunsCaptureTestWithoutErrors)  {
   ASSERT_EQ(0, tests_->ViECaptureStandardTest());
 }
 
-TEST_F(ViEStandardIntegrationTest, RunsCodecTestWithoutErrors)  {
-  ASSERT_EQ(0, tests_->ViECodecStandardTest());
-}
 
 TEST_F(ViEStandardIntegrationTest, RunsEncryptionTestWithoutErrors)  {
   ASSERT_EQ(0, tests_->ViEEncryptionStandardTest());

src/video_engine/main/test/AutoTest/helpers/vie_fake_camera.cc

@@ -0,0 +1,82 @@
+/*
+ *  Copyright (c) 2011 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 "vie_fake_camera.h"
+
+#include <assert.h>
+
+#include "vie_capture.h"
+#include "vie_file_capture_device.h"
+#include "thread_wrapper.h"
+
+// This callback runs the camera thread:
+bool StreamVideoFileRepeatedlyIntoCaptureDevice(void* data) {
+  ViEFileCaptureDevice* file_capture_device =
+      reinterpret_cast<ViEFileCaptureDevice*>(data);
+
+  uint64_t time_slice_ms = 1500;
+  uint32_t max_fps = 30;
+  file_capture_device->ReadFileFor(time_slice_ms, max_fps);
+
+  return true;
+}
+
+ViEFakeCamera::ViEFakeCamera(webrtc::ViECapture* capture_interface)
+    : capture_interface_(capture_interface),
+      camera_thread_(NULL),
+      file_capture_device_(NULL) {
+}
+
+ViEFakeCamera::~ViEFakeCamera() {
+}
+
+bool ViEFakeCamera::StartCameraInNewThread(
+    const std::string& i420_test_video_path, int width, int height) {
+
+  assert(file_capture_device_ == NULL && camera_thread_ == NULL);
+
+  webrtc::ViEExternalCapture* externalCapture;
+  int result = capture_interface_->
+      AllocateExternalCaptureDevice(capture_id_, externalCapture);
+  if (result != 0) {
+    return false;
+  }
+
+  file_capture_device_ = new ViEFileCaptureDevice(externalCapture);
+  if (!file_capture_device_->OpenI420File(i420_test_video_path,
+                                          width,
+                                          height)) {
+    return false;
+  }
+
+  // Set up a thread which runs the fake camera. The capturer object is
+  // thread-safe.
+  camera_thread_ = webrtc::ThreadWrapper::CreateThread(
+      StreamVideoFileRepeatedlyIntoCaptureDevice, file_capture_device_);
+  unsigned int id;
+  camera_thread_->Start(id);
+
+  return true;
+}
+
+bool ViEFakeCamera::StopCamera() {
+  assert(file_capture_device_ != NULL && camera_thread_ != NULL);
+
+  camera_thread_->Stop();
+  file_capture_device_->CloseFile();
+
+  int result = capture_interface_->ReleaseCaptureDevice(capture_id_);
+
+  delete camera_thread_;
+  delete file_capture_device_;
+  camera_thread_ = NULL;
+  file_capture_device_ = NULL;
+
+  return result == 0;
+}

src/video_engine/main/test/AutoTest/helpers/vie_fake_camera.h

@@ -0,0 +1,50 @@
+/*
+ *  Copyright (c) 2011 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 SRC_VIDEO_ENGINE_MAIN_TEST_AUTOTEST_HELPERS_VIE_FAKE_CAMERA_H_
+#define SRC_VIDEO_ENGINE_MAIN_TEST_AUTOTEST_HELPERS_VIE_FAKE_CAMERA_H_
+
+#include <string>
+
+namespace webrtc {
+class ViECapture;
+class ThreadWrapper;
+}
+
+class ViEFileCaptureDevice;
+
+// Registers an external capture device with the provided capture interface
+// and starts running a fake camera by reading frames from a file. The frame-
+// reading code runs in a separate thread which makes it possible to run tests
+// while the fake camera feeds data into the system. This class is not thread-
+// safe in itself (but handles its own thread in a safe manner).
+class ViEFakeCamera {
+ public:
+  // The argument is the capture interface to register with.
+  explicit ViEFakeCamera(webrtc::ViECapture* capture_interface);
+  virtual ~ViEFakeCamera();
+
+  // Runs the scenario in the class comments.
+  bool StartCameraInNewThread(const std::string& i420_test_video_path,
+                              int width,
+                              int height);
+  // Stops the camera and cleans up everything allocated by the start method.
+  bool StopCamera();
+
+  int capture_id() const { return capture_id_; }
+
+ private:
+  webrtc::ViECapture* capture_interface_;
+
+  int capture_id_;
+  webrtc::ThreadWrapper* camera_thread_;
+  ViEFileCaptureDevice* file_capture_device_;
+};
+
+#endif  // SRC_VIDEO_ENGINE_MAIN_TEST_AUTOTEST_HELPERS_VIE_FAKE_CAMERA_H_

src/video_engine/main/test/AutoTest/helpers/vie_file_capture_device.cc

@@ -9,6 +9,8 @@
  */
 #include "vie_file_capture_device.h"
 
+#include <assert.h>
+
 #include "common_types.h"
 #include "critical_section_wrapper.h"
 #include "event_wrapper.h"

src/video_engine/main/test/AutoTest/helpers/vie_file_capture_device.h

@@ -23,10 +23,8 @@ class EventWrapper;
 class ViEExternalCapture;
 }
 
-/**
- * This class opens a i420 file and feeds it into a ExternalCapture instance,
- * thereby acting as a faked capture device with deterministic input.
- */
+// This class opens a i420 file and feeds it into a ExternalCapture instance,
+// thereby acting as a faked capture device with deterministic input.
 class ViEFileCaptureDevice {
  public:
   // The input sink is where to send the I420 video frames.

src/video_engine/main/test/AutoTest/interface/vie_autotest.h

@@ -39,6 +39,8 @@
 #include <string>
 #endif
 
+class tbInterfaces;
+
 class ViEAutoTest
 {
 public:
@@ -77,6 +79,10 @@ class ViEAutoTest
     int ViECodecExternalCodecTest();
     int ViECodecAPITest();
 
+    void ViEAutomatedCodecStandardTest(const std::string& pathToTestI420Video,
+                                       int width,
+                                       int height);
+
     // vie_autotest_encryption.cc
     int ViEEncryptionStandardTest();
     int ViEEncryptionExtendedTest();
@@ -126,6 +132,10 @@ class ViEAutoTest
     void PrintAudioCodec(const webrtc::CodecInst audioCodec);
     void PrintVideoCodec(const webrtc::VideoCodec videoCodec);
 
+    void RunCodecTestInternal(const tbInterfaces& interfaces,
+                              int & numberOfErrors,
+                              int captureId);
+
     void* _window1;
     void* _window2;
 

src/video_engine/main/test/AutoTest/source/vie_autotest_base.cc

@@ -13,12 +13,12 @@
 //
 
 #include "gtest/gtest.h"
-
-#include "thread_wrapper.h"
-#include "vie_autotest.h"
-#include "vie_autotest_defines.h"
 #include "video_capture_factory.h"
+#include "vie_autotest_defines.h"
+#include "vie_autotest.h"
+#include "vie_fake_camera.h"
 #include "vie_file_capture_device.h"
+#include "thread_wrapper.h"
 
 class BaseObserver : public webrtc::ViEBaseObserver {
  public:
@@ -238,9 +238,6 @@ void StopEverything(webrtc::ViEBase * ptrViEBase,
   error = ptrViECapture->DisconnectCaptureDevice(videoChannel);
   numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
                                        __FUNCTION__, __LINE__);
-  error = ptrViECapture->ReleaseCaptureDevice(captureId);
-  numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
-                                       __FUNCTION__, __LINE__);
 }
 
 void ReleaseEverything(webrtc::ViECapture *ptrViECapture,
@@ -355,6 +352,10 @@ int ViEAutoTest::ViEBaseStandardTest() {
   StopEverything(ptrViEBase, videoChannel, numberOfErrors, ptrViERender,
                  captureId, ptrViECapture, _vrm1, _vrm2);
 
+  error = ptrViECapture->ReleaseCaptureDevice(captureId);
+  numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d",
+                                         __FUNCTION__, __LINE__);
+
   vcpm->Release();
   vcpm = NULL;
 
@@ -590,18 +591,6 @@ int ViEAutoTest::ViEBaseAPITest() {
   return 0;
 }
 
-// This callback gets used in the automated test case below:
-bool StreamVideoFileRepeatedlyIntoCaptureDevice(void* data) {
-  ViEFileCaptureDevice* file_capture_device =
-      reinterpret_cast<ViEFileCaptureDevice*>(data);
-
-  WebRtc_UWord64 time_slice_ms = 1500;
-  WebRtc_UWord64 max_fps = 30;
-  file_capture_device->ReadFileFor(time_slice_ms, max_fps);
-
-  return true;
-}
-
 void ViEAutoTest::ViEAutomatedBaseStandardTest(
     const std::string& pathToTestI420Video, int width, int height) {
   int ignoredNumberOfErrors;
@@ -617,29 +606,15 @@ void ViEAutoTest::ViEAutomatedBaseStandardTest(
       InitializeChannel(ptrViEBase, videoChannel,
                         ignoredNumberOfErrors, ptrViE);
 
-  int captureId;
-  webrtc::ViEExternalCapture* externalCapture;
-  int error = ptrViECapture->AllocateExternalCaptureDevice(captureId,
-                                                           externalCapture);
-  ViETest::TestError(error == 0, "ERROR: %s at line %d",
-                     __FUNCTION__, __LINE__);
-
-  ViEFileCaptureDevice capturer(externalCapture);
-  if (!capturer.OpenI420File(pathToTestI420Video, width, height)) {
+  ViEFakeCamera fakeCamera(ptrViECapture);
+  if (!fakeCamera.StartCameraInNewThread(pathToTestI420Video, width, height)) {
     // No point in continuing if we have no proper video source
     ViETest::TestError(false, "ERROR: %s at line %d: "
                        "Could not open input video %s: aborting test...",
                        __FUNCTION__, __LINE__, pathToTestI420Video.c_str());
     return;
   }
-
-  // Set up a thread which runs the fake camera. Note that the capturer is
-  // handed off to the other thread - it should not be touched in this
-  // method until the other thread is stopped!
-  webrtc::ThreadWrapper* thread = webrtc::ThreadWrapper::CreateThread(
-      StreamVideoFileRepeatedlyIntoCaptureDevice, &capturer);
-  unsigned int id;
-  thread->Start(id);
+  int captureId = fakeCamera.capture_id();
 
   // Apparently, we need to connect external capture devices, but we should
   // not start them since the external device is not a proper device.
@@ -667,13 +642,15 @@ void ViEAutoTest::ViEAutomatedBaseStandardTest(
 
   AutoTestSleep(KAutoTestSleepTimeMs);
 
-  // Done, clean up
-  thread->Stop();
-  capturer.CloseFile();
-
   StopEverything(ptrViEBase, videoChannel, ignoredNumberOfErrors, ptrViERender,
                  captureId, ptrViECapture, _vrm1, _vrm2);
 
+  // Stop sending data, clean up the camera thread and release the capture
+  // device. Note that this all happens after StopEverything, so this is
+  // tests that the system doesn't mind that the external capture device sends
+  // data after rendering has been stopped.
+  fakeCamera.StopCamera();
+
   ReleaseEverything(ptrViECapture, ignoredNumberOfErrors, ptrViEBase,
                     videoChannel, ptrViECodec, ptrViERtpRtcp, ptrViERender,
                     ptrViENetwork, ptrViE);