/*
 *  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.
 */

#include "vie_autotest.h"

#include "common_types.h"
#include "engine_configurations.h"
#include "gflags/gflags.h"
#include "tb_interfaces.h"
#include "tb_video_channel.h"
#include "tick_util.h"
#include "vie_autotest_defines.h"
#include "video_capture_factory.h"
#include "vie_base.h"
#include "vie_capture.h"
#include "vie_codec.h"
#include "vie_network.h"
#include "vie_render.h"
#include "vie_rtp_rtcp.h"
#include "voe_base.h"

DEFINE_bool(capture_test_ensure_resolution_alignment_in_capture_device, true,
            "If true, we will give resolutions slightly below a reasonable "
            "value to test the camera's ability to choose a good resolution. "
            "If false, we will provide reasonable resolutions instead.");

class CaptureObserver: public webrtc::ViECaptureObserver
{
public:
    CaptureObserver() :
        _brightness(webrtc::Normal),
        _alarm(webrtc::AlarmCleared),
        _frameRate(0) {}

    virtual void BrightnessAlarm(const int captureId,
                                 const webrtc::Brightness brightness)
    {
        _brightness = brightness;
        switch (brightness)
        {
            case webrtc::Normal:
                ViETest::Log("  BrightnessAlarm Normal");
                break;
            case webrtc::Bright:
                ViETest::Log("  BrightnessAlarm Bright");
                break;
            case webrtc::Dark:
                ViETest::Log("  BrightnessAlarm Dark");
                break;
        }
    }

    virtual void CapturedFrameRate(const int captureId,
                                   const unsigned char frameRate)
    {
        ViETest::Log("  CapturedFrameRate %u", frameRate);
        _frameRate = frameRate;
    }

    virtual void NoPictureAlarm(const int captureId,
                                const webrtc::CaptureAlarm alarm)
    {
        _alarm = alarm;
        if (alarm == webrtc::AlarmRaised)
        {
            ViETest::Log("NoPictureAlarm CARaised.");
        }
        else
        {
            ViETest::Log("NoPictureAlarm CACleared.");
        }
    }

    webrtc::Brightness _brightness;
    webrtc::CaptureAlarm _alarm;
    unsigned char _frameRate;
};

class CaptureEffectFilter: public webrtc::ViEEffectFilter {
 public:
  CaptureEffectFilter(unsigned int expected_width, unsigned int expected_height)
    : number_of_captured_frames_(0),
      expected_width_(expected_width),
      expected_height_(expected_height) {
  }

  // Implements ViEEffectFilter
  virtual int Transform(int size, unsigned char* frameBuffer,
                        unsigned int timeStamp90KHz, unsigned int width,
                        unsigned int height) {
    EXPECT_TRUE(frameBuffer != NULL);
    EXPECT_EQ(expected_width_, width);
    EXPECT_EQ(expected_height_, height);
    ++number_of_captured_frames_;
    return 0;
  }

  int number_of_captured_frames_;

 protected:
  unsigned int expected_width_;
  unsigned int expected_height_;
 };

void ViEAutoTest::ViECaptureStandardTest()
{
    //***************************************************************
    //	Begin create/initialize WebRTC Video Engine for testing
    //***************************************************************

    //***************************************************************
    //	Engine ready. Begin testing class
    //***************************************************************

    TbInterfaces ViE("ViECaptureStandardTest");

    webrtc::VideoCaptureModule::DeviceInfo* devInfo =
        webrtc::VideoCaptureFactory::CreateDeviceInfo(0);

    int numberOfCaptureDevices = devInfo->NumberOfDevices();
    ViETest::Log("Number of capture devices %d", numberOfCaptureDevices);
    EXPECT_GT(numberOfCaptureDevices, 0);

    int captureDeviceId[10];
    memset(captureDeviceId, 0, sizeof(captureDeviceId));
    webrtc::VideoCaptureModule* vcpms[10];
    memset(vcpms, 0, sizeof(vcpms));

    // Check capabilities
    for (int deviceIndex = 0;
         deviceIndex < numberOfCaptureDevices;
         ++deviceIndex)
    {
        WebRtc_UWord8 deviceName[128];
        WebRtc_UWord8 deviceUniqueName[512];

        EXPECT_EQ(0, devInfo->GetDeviceName(deviceIndex,
                                            deviceName,
                                            sizeof(deviceName),
                                            deviceUniqueName,
                                            sizeof(deviceUniqueName)));
        ViETest::Log("Found capture device %s\nUnique name %s", deviceName,
                     deviceUniqueName);

#if !defined(WEBRTC_MAC_INTEL)  // these functions will return -1
        int numberOfCapabilities =
            devInfo->NumberOfCapabilities(deviceUniqueName);
        EXPECT_GT(numberOfCapabilities, 0);

        for (int capIndex = 0; capIndex < numberOfCapabilities; ++capIndex)
        {
            webrtc::VideoCaptureCapability capability;
            EXPECT_EQ(0, devInfo->GetCapability(deviceUniqueName, capIndex,
                                                capability));
            ViETest::Log("Capture capability %d (of %u)", capIndex + 1,
                         numberOfCapabilities);
            ViETest::Log("witdh %d, height %d, frame rate %d",
                         capability.width, capability.height, capability.maxFPS);
            ViETest::Log("expected delay %d, color type %d, encoding %d",
                         capability.expectedCaptureDelay, capability.rawType,
                         capability.codecType);

            EXPECT_GT(capability.width, 0);
            EXPECT_GT(capability.height, 0);
            EXPECT_GT(capability.maxFPS, -1);  // >= 0
            EXPECT_GT(capability.expectedCaptureDelay, 0);
        }
#endif
    }
    // Capture Capability Functions are not supported on WEBRTC_MAC_INTEL.
#if !defined(WEBRTC_MAC_INTEL)

    // Check allocation. Try to allocate them all after each other.
    for (int deviceIndex = 0;
         deviceIndex < numberOfCaptureDevices;
         ++deviceIndex)
    {
        WebRtc_UWord8 deviceName[128];
        WebRtc_UWord8 deviceUniqueName[512];

        EXPECT_EQ(0, devInfo->GetDeviceName(deviceIndex,
                                            deviceName,
                                            sizeof(deviceName),
                                            deviceUniqueName,
                                            sizeof(deviceUniqueName)));

        webrtc::VideoCaptureModule* vcpm =
            webrtc::VideoCaptureFactory::Create(
                deviceIndex, deviceUniqueName);
        EXPECT_TRUE(vcpm != NULL);
        vcpm->AddRef();
        vcpms[deviceIndex] = vcpm;

        EXPECT_EQ(0, ViE.capture->AllocateCaptureDevice(
            *vcpm, captureDeviceId[deviceIndex]));

        webrtc::VideoCaptureCapability capability;
        EXPECT_EQ(0, devInfo->GetCapability(deviceUniqueName, 0, capability));

        // Test that the camera select the closest capability to the selected
        // width and height.
        CaptureEffectFilter filter(capability.width, capability.height);
        EXPECT_EQ(0, ViE.image_process->RegisterCaptureEffectFilter(
            captureDeviceId[deviceIndex], filter));

        ViETest::Log("Testing Device %s capability width %d  height %d",
                     deviceUniqueName, capability.width, capability.height);

        if (FLAGS_capture_test_ensure_resolution_alignment_in_capture_device) {
          // This tests that the capture device properly aligns to a
          // multiple of 16 (or at least 8).
          capability.height = capability.height - 2;
          capability.width  = capability.width  - 2;
        }

        webrtc::CaptureCapability vieCapability;
        vieCapability.width = capability.width;
        vieCapability.height = capability.height;
        vieCapability.codecType = capability.codecType;
        vieCapability.maxFPS = capability.maxFPS;
        vieCapability.rawType = capability.rawType;

        EXPECT_EQ(0, ViE.capture->StartCapture(captureDeviceId[deviceIndex],
                                               vieCapability));
        webrtc::TickTime startTime = webrtc::TickTime::Now();

        while (filter.number_of_captured_frames_ < 10
               && (webrtc::TickTime::Now() - startTime).Milliseconds() < 10000)
        {
            AutoTestSleep(100);
        }

        EXPECT_GT(filter.number_of_captured_frames_, 9) <<
            "Should capture at least some frames";

        EXPECT_EQ(0, ViE.image_process->DeregisterCaptureEffectFilter(
            captureDeviceId[deviceIndex]));

#ifdef WEBRTC_ANDROID  // Can only allocate one camera at the time on Android.
        EXPECT_EQ(0, ViE.capture->StopCapture(captureDeviceId[deviceIndex]));
        EXPECT_EQ(0, ViE.capture->ReleaseCaptureDevice(
            captureDeviceId[deviceIndex]));
#endif
    }

    //***************************************************************
    //	Testing finished. Tear down Video Engine
    //***************************************************************


    // Stop all started capture devices.
    for (int deviceIndex = 0;
        deviceIndex < numberOfCaptureDevices;
        ++deviceIndex) {
#if !defined(WEBRTC_ANDROID)
      // Don't stop on Android since we can only allocate one camera.
      EXPECT_EQ(0, ViE.capture->StopCapture(
          captureDeviceId[deviceIndex]));
      EXPECT_EQ(0, ViE.capture->ReleaseCaptureDevice(
          captureDeviceId[deviceIndex]));
#endif  // !WEBRTC_ANDROID
      vcpms[deviceIndex]->Release();
    }
#endif  // !WEBRTC_MAC_INTEL
}

void ViEAutoTest::ViECaptureExtendedTest() {
    ViECaptureStandardTest();
    ViECaptureAPITest();
    ViECaptureExternalCaptureTest();
}

void ViEAutoTest::ViECaptureAPITest()
{
    //***************************************************************
    //	Begin create/initialize WebRTC Video Engine for testing
    //***************************************************************

    //***************************************************************
    //	Engine ready. Begin testing class
    //***************************************************************
    TbInterfaces ViE("ViECaptureAPITest");

    ViE.capture->NumberOfCaptureDevices();

    WebRtc_UWord8 deviceName[128];
    WebRtc_UWord8 deviceUniqueName[512];
    int captureId = 0;

    webrtc::VideoCaptureModule::DeviceInfo* devInfo =
        webrtc::VideoCaptureFactory::CreateDeviceInfo(0);
    EXPECT_TRUE(devInfo != NULL);

    // Get the first capture device
    EXPECT_EQ(0, devInfo->GetDeviceName(0, deviceName,
                                        sizeof(deviceName),
                                        deviceUniqueName,
                                        sizeof(deviceUniqueName)));

    webrtc::VideoCaptureModule* vcpm =
        webrtc::VideoCaptureFactory::Create(0, deviceUniqueName);
    vcpm->AddRef();
    EXPECT_TRUE(vcpm != NULL);

    // Allocate capture device.
    EXPECT_EQ(0, ViE.capture->AllocateCaptureDevice(*vcpm, captureId));

    // Start the capture device.
    EXPECT_EQ(0, ViE.capture->StartCapture(captureId));

    // Start again. Should fail.
    EXPECT_NE(0, ViE.capture->StartCapture(captureId));
    EXPECT_EQ(kViECaptureDeviceAlreadyStarted, ViE.LastError());

    // Start invalid capture device.
    EXPECT_NE(0, ViE.capture->StartCapture(captureId + 1));
    EXPECT_EQ(kViECaptureDeviceDoesNotExist, ViE.LastError());

    // Stop invalid capture device.
    EXPECT_NE(0, ViE.capture->StopCapture(captureId + 1));
    EXPECT_EQ(kViECaptureDeviceDoesNotExist, ViE.LastError());

    // Stop the capture device.
    EXPECT_EQ(0, ViE.capture->StopCapture(captureId));

    // Stop the capture device again.
    EXPECT_NE(0, ViE.capture->StopCapture(captureId));
    EXPECT_EQ(kViECaptureDeviceNotStarted, ViE.LastError());

    // Connect to invalid channel.
    EXPECT_NE(0, ViE.capture->ConnectCaptureDevice(captureId, 0));
    EXPECT_EQ(kViECaptureDeviceInvalidChannelId, ViE.LastError());

    TbVideoChannel channel(ViE);

    // Connect invalid captureId.
    EXPECT_NE(0, ViE.capture->ConnectCaptureDevice(captureId + 1,
                                                   channel.videoChannel));
    EXPECT_EQ(kViECaptureDeviceDoesNotExist, ViE.LastError());

    // Connect the capture device to the channel.
    EXPECT_EQ(0, ViE.capture->ConnectCaptureDevice(captureId,
                                                   channel.videoChannel));

    // Connect the channel again.
    EXPECT_NE(0, ViE.capture->ConnectCaptureDevice(captureId,
                                                   channel.videoChannel));
    EXPECT_EQ(kViECaptureDeviceAlreadyConnected, ViE.LastError());

    // Start the capture device.
    EXPECT_EQ(0, ViE.capture->StartCapture(captureId));

    // Release invalid capture device.
    EXPECT_NE(0, ViE.capture->ReleaseCaptureDevice(captureId + 1));
    EXPECT_EQ(kViECaptureDeviceDoesNotExist, ViE.LastError());

    // Release the capture device.
    EXPECT_EQ(0, ViE.capture->ReleaseCaptureDevice(captureId));

    // Release the capture device again.
    EXPECT_NE(0, ViE.capture->ReleaseCaptureDevice(captureId));
    EXPECT_EQ(kViECaptureDeviceDoesNotExist, ViE.LastError());

    // Test GetOrientation.
    webrtc::VideoCaptureRotation orientation;
    WebRtc_UWord8 dummy_name[5];
    EXPECT_NE(0, devInfo->GetOrientation(dummy_name, orientation));

    // Test SetRotation.
    EXPECT_NE(0, ViE.capture->SetRotateCapturedFrames(
        captureId, webrtc::RotateCapturedFrame_90));
    EXPECT_EQ(kViECaptureDeviceDoesNotExist, ViE.LastError());

    // Allocate capture device.
    EXPECT_EQ(0, ViE.capture->AllocateCaptureDevice(*vcpm, captureId));

    EXPECT_EQ(0, ViE.capture->SetRotateCapturedFrames(
        captureId, webrtc::RotateCapturedFrame_0));
    EXPECT_EQ(0, ViE.capture->SetRotateCapturedFrames(
        captureId, webrtc::RotateCapturedFrame_90));
    EXPECT_EQ(0, ViE.capture->SetRotateCapturedFrames(
        captureId, webrtc::RotateCapturedFrame_180));
    EXPECT_EQ(0, ViE.capture->SetRotateCapturedFrames(
        captureId, webrtc::RotateCapturedFrame_270));

    // Release the capture device
    EXPECT_EQ(0, ViE.capture->ReleaseCaptureDevice(captureId));

    //***************************************************************
    //	Testing finished. Tear down Video Engine
    //***************************************************************
    delete devInfo;
    vcpm->Release();
}

void ViEAutoTest::ViECaptureExternalCaptureTest()
{
    //***************************************************************
    //	Begin create/initialize WebRTC Video Engine for testing
    //***************************************************************

    TbInterfaces ViE("ViECaptureExternalCaptureTest");
    TbVideoChannel channel(ViE);
    channel.StartReceive();
    channel.StartSend();

    webrtc::VideoCaptureExternal* externalCapture;
    int captureId = 0;

    // Allocate the external capture device.
    webrtc::VideoCaptureModule* vcpm = webrtc::VideoCaptureFactory::Create(
        0, externalCapture);
    EXPECT_TRUE(vcpm != NULL);
    EXPECT_TRUE(externalCapture != NULL);
    vcpm->AddRef();

    EXPECT_EQ(0, ViE.capture->AllocateCaptureDevice(*vcpm, captureId));

    // Connect the capture device to the channel.
    EXPECT_EQ(0, ViE.capture->ConnectCaptureDevice(captureId,
                                                   channel.videoChannel));

    // Render the local capture.
    EXPECT_EQ(0, ViE.render->AddRenderer(captureId, _window1, 1, 0.0, 0.0,
                                         1.0, 1.0));

    // Render the remote capture.
    EXPECT_EQ(0, ViE.render->AddRenderer(channel.videoChannel, _window2, 1,
                                         0.0, 0.0, 1.0, 1.0));
    EXPECT_EQ(0, ViE.render->StartRender(captureId));
    EXPECT_EQ(0, ViE.render->StartRender(channel.videoChannel));

    // Register observer.
    CaptureObserver observer;
    EXPECT_EQ(0, ViE.capture->RegisterObserver(captureId, observer));

    // Enable brightness alarm.
    EXPECT_EQ(0, ViE.capture->EnableBrightnessAlarm(captureId, true));

    CaptureEffectFilter effectFilter(176, 144);
    EXPECT_EQ(0, ViE.image_process->RegisterCaptureEffectFilter(captureId,
                                                                effectFilter));

    // Call started.
    ViETest::Log("You should see local preview from external capture\n"
                 "in window 1 and the remote video in window 2.\n");

    //***************************************************************
    //	Engine ready. Begin testing class
    //***************************************************************
    const unsigned int videoFrameLength = (176 * 144 * 3) / 2;
    unsigned char* videoFrame = new unsigned char[videoFrameLength];
    memset(videoFrame, 128, 176 * 144);

    int frameCount = 0;
    webrtc::VideoCaptureCapability capability;
    capability.width = 176;
    capability.height = 144;
    capability.rawType = webrtc::kVideoI420;

    ViETest::Log("Testing external capturing and frame rate callbacks.");
    // TODO: Change when using a real file!
    // while (fread(videoFrame, videoFrameLength, 1, foreman) == 1)
    while (frameCount < 120)
    {
        externalCapture->IncomingFrame(
            videoFrame, videoFrameLength, capability,
            webrtc::TickTime::Now().MillisecondTimestamp());
        AutoTestSleep(33);

        if (effectFilter.number_of_captured_frames_ > 2)
        {
            EXPECT_EQ(webrtc::Normal, observer._brightness) <<
                "Brightness or picture alarm should not have been called yet.";
            EXPECT_EQ(webrtc::AlarmCleared, observer._alarm) <<
                "Brightness or picture alarm should not have been called yet.";
        }
        frameCount++;
    }

    // Test brightness alarm
    // Test bright image
    for (int i = 0; i < 176 * 144; ++i)
    {
        if (videoFrame[i] <= 155)
            videoFrame[i] = videoFrame[i] + 100;
        else
            videoFrame[i] = 255;
    }
    ViETest::Log("Testing Brighness alarm");
    for (int frame = 0; frame < 30; ++frame)
    {
        externalCapture->IncomingFrame(
            videoFrame, videoFrameLength, capability,
            webrtc::TickTime::Now().MillisecondTimestamp());
        AutoTestSleep(33);
    }
    EXPECT_EQ(webrtc::Bright, observer._brightness) <<
        "Should be bright at this point since we are using a bright image.";

    // Test Dark image
    for (int i = 0; i < 176 * 144; ++i)
    {
        videoFrame[i] = videoFrame[i] > 200 ? videoFrame[i] - 200 : 0;
    }
    for (int frame = 0; frame < 30; ++frame)
    {
        externalCapture->IncomingFrame(
            videoFrame, videoFrameLength, capability,
            webrtc::TickTime::Now().MillisecondTimestamp());
        AutoTestSleep(33);
    }
    EXPECT_EQ(webrtc::Dark, observer._brightness) <<
        "Should be dark at this point since we are using a dark image.";
    EXPECT_GT(effectFilter.number_of_captured_frames_, 150) <<
        "Frames should have been played.";

    EXPECT_GE(observer._frameRate, 29) <<
        "Frame rate callback should be approximately correct.";
    EXPECT_LE(observer._frameRate, 30) <<
        "Frame rate callback should be approximately correct.";

    // Test no picture alarm
    ViETest::Log("Testing NoPictureAlarm.");
    AutoTestSleep(1050);

    EXPECT_EQ(webrtc::AlarmRaised, observer._alarm) <<
        "No picture alarm should be raised.";
    for (int frame = 0; frame < 10; ++frame)
    {
        externalCapture->IncomingFrame(
            videoFrame, videoFrameLength, capability,
            webrtc::TickTime::Now().MillisecondTimestamp());
        AutoTestSleep(33);
    }
    EXPECT_EQ(webrtc::AlarmCleared, observer._alarm) <<
        "Alarm should be cleared since ge just got some data.";

    delete videoFrame;

    // Release the capture device
    EXPECT_EQ(0, ViE.capture->ReleaseCaptureDevice(captureId));

    // Release the capture device again
    EXPECT_NE(0, ViE.capture->ReleaseCaptureDevice(captureId));
    EXPECT_EQ(kViECaptureDeviceDoesNotExist, ViE.LastError());
    vcpm->Release();

    //***************************************************************
    //	Testing finished. Tear down Video Engine
    //***************************************************************
}