/*
 * Copyright (c) 2016 - 2018, NVIDIA CORPORATION. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *  * Neither the name of NVIDIA CORPORATION nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "ArgusHelpers.h"
#include "CommonOptions.h"
#include "Error.h"
#include "Thread.h"

#include <Argus/Argus.h>
#include <EGLStream/EGLStream.h>

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

#include <string.h>
#include <unistd.h>
#include <stdbool.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>

#include "PreviewConsumer.h"

using namespace Argus;
using namespace EGLStream;
// Extensions used by this demo
#define EXTENSION_LIST(T) \
    T( PFNEGLQUERYSTREAMKHRPROC,           eglQueryStreamKHR ) \
    T( PFNEGLQUERYSTREAMU64KHRPROC,        eglQueryStreamu64KHR ) \
    T( PFNEGLSTREAMCONSUMERACQUIREKHRPROC, eglStreamConsumerAcquireKHR ) \
    T( PFNEGLSTREAMCONSUMERRELEASEKHRPROC, eglStreamConsumerReleaseKHR ) \
    T( PFNEGLCREATESTREAMKHRPROC,          eglCreateStreamKHR ) \
    T( PFNEGLDESTROYSTREAMKHRPROC,         eglDestroyStreamKHR ) \
    T( PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC, \
                        eglStreamConsumerGLTextureExternalKHR ) \
    T( PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC, \
                        eglGetStreamFileDescriptorKHR ) \
    T( PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC, \
                        eglCreateStreamFromFileDescriptorKHR )

#define EXTLST_DECL(tx, x) static tx x = NULL;
#define EXTLST_ENTRY(tx, x) { (extlst_fnptr_t *)&x, #x },

EXTENSION_LIST(EXTLST_DECL)
typedef void (*extlst_fnptr_t)(void);
static const struct {
    extlst_fnptr_t *fnptr;
    char const *name;
} extensionList[] = { EXTENSION_LIST(EXTLST_ENTRY) };

namespace ArgusSamples
{

#ifdef ANDROID
#define JPEG_PREFIX "/sdcard/DCIM/Argus_"
#else
#define JPEG_PREFIX ""
#endif

// Debug print macros.
#define PRODUCER_PRINT(...) printf("PRODUCER: " __VA_ARGS__)
#define CONSUMER_PRINT(...) printf("CONSUMER: " __VA_ARGS__)

static const Rectangle<uint32_t> DEFAULT_WINDOW_RECT(0, 0, 1920,1080);


int connect_fd = -1;
int send_fd = -1;
EGLNativeFileDescriptorKHR fileDescriptor = EGL_NO_FILE_DESCRIPTOR_KHR;

#define SOCK_PATH       "/tmp/tegra_sw_egl_socket"


/*******************************************************************************
 * FrameConsumer thread:
 *   Creates a FrameConsumer object to read frames from the OutputStream, then
 *   acquires and prints frame info from the IImage and IImage2D interfaces
 *   while frames are presented. It will also write JPEG files to disk using the
 *   IImageJPEG interface.
 ******************************************************************************/
class ConsumerThread : public Thread
{
public:
    explicit ConsumerThread(OutputStream* stream) :
        m_stream(stream)
    {
    }
    ~ConsumerThread()
    {
    }

private:
    /** @name Thread methods */
    /**@{*/
    virtual bool threadInitialize();
    virtual bool threadExecute();
    virtual bool threadShutdown();
    /**@}*/

    OutputStream* m_stream;
    UniqueObj<FrameConsumer> m_consumer;
};

bool ConsumerThread::threadInitialize()
{
    // Create the FrameConsumer.
    m_consumer = UniqueObj<FrameConsumer>(FrameConsumer::create(m_stream));
    if (!m_consumer)
        ORIGINATE_ERROR("Failed to create FrameConsumer");

    return true;
}

bool ConsumerThread::threadExecute()
{
    IEGLOutputStream *iStream = interface_cast<IEGLOutputStream>(m_stream);
    IFrameConsumer *iFrameConsumer = interface_cast<IFrameConsumer>(m_consumer);

    // Wait until the producer has connected to the stream.
    CONSUMER_PRINT("Waiting until producer is connected...\n");
    if (iStream->waitUntilConnected() != STATUS_OK)
        ORIGINATE_ERROR("Stream failed to connect.");
    CONSUMER_PRINT("Producer has connected; continuing.\n");

    while (true)
    {
        UniqueObj<Frame> frame(iFrameConsumer->acquireFrame());
        if (!frame)
            break;

        // Use the IFrame interface to print out the frame number/timestamp, and
        // to provide access to the Image in the Frame.
        IFrame *iFrame = interface_cast<IFrame>(frame);
        if (!iFrame)
            ORIGINATE_ERROR("Failed to get IFrame interface.");
        CONSUMER_PRINT("Acquired Frame: %llu, time %llu\n",
                       static_cast<unsigned long long>(iFrame->getNumber()),
                       static_cast<unsigned long long>(iFrame->getTime()));

        // Print out some capture metadata from the frame.
        IArgusCaptureMetadata *iArgusCaptureMetadata = interface_cast<IArgusCaptureMetadata>(frame);
        if (!iArgusCaptureMetadata)
            ORIGINATE_ERROR("Failed to get IArgusCaptureMetadata interface.");
        CaptureMetadata *metadata = iArgusCaptureMetadata->getMetadata();
        ICaptureMetadata *iMetadata = interface_cast<ICaptureMetadata>(metadata);
        if (!iMetadata)
            ORIGINATE_ERROR("Failed to get ICaptureMetadata interface.");
        CONSUMER_PRINT("\tSensor Timestamp: %llu, LUX: %f\n",
                       static_cast<unsigned long long>(iMetadata->getSensorTimestamp()),
                       iMetadata->getSceneLux());

        // Print out image details, and map the buffers to read out some data.
        Image *image = iFrame->getImage();
        IImage *iImage = interface_cast<IImage>(image);
        IImage2D *iImage2D = interface_cast<IImage2D>(image);
        for (uint32_t i = 0; i < iImage->getBufferCount(); i++)
        {
            const uint8_t *d = static_cast<const uint8_t*>(iImage->mapBuffer(i));
            if (!d)
                ORIGINATE_ERROR("\tFailed to map buffer\n");

            Size2D<uint32_t> size = iImage2D->getSize(i);
            CONSUMER_PRINT("\tIImage(2D): "
                           "buffer %u (%ux%u, %u stride), "
                           "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
                           i, size.width(), size.height(), iImage2D->getStride(i),
                           d[0], d[1], d[2], d[3], d[4], d[5],
                           d[6], d[7], d[8], d[9], d[10], d[11]);
        }

        // Write a JPEG to disk.
        IImageJPEG *iJPEG = interface_cast<IImageJPEG>(image);
        if (iJPEG)
        {
            char path[256];
            snprintf(path, sizeof(path), JPEG_PREFIX"%llu.JPG",
                     static_cast<unsigned long long>(iFrame->getNumber()));
            Argus::Status status = iJPEG->writeJPEG(path);
            if (status == STATUS_OK)
                CONSUMER_PRINT("\tWrote JPEG: %s\n", path);
            else
                CONSUMER_PRINT("\tFailed to write JPEG: %s (status %d)\n", path, status);
        }
    }

    CONSUMER_PRINT("Done.\n");

    PROPAGATE_ERROR(requestShutdown());

    return true;
}

bool ConsumerThread::threadShutdown()
{
    return true;
}

static int UnixSocketConnect(const char *socket_name)
{
    int sock_fd=-1;
    struct sockaddr_un sock_addr;
    int wait_loop = 0;

    sock_fd = socket(PF_UNIX, SOCK_STREAM, 0);
    if(sock_fd < 0) {
        printf("%s: socket create failed.\n", __func__);
        return -1;
    }

    if (1)
        printf("%s: send_fd: sock_fd: %d\n", __func__, sock_fd);

    memset(&sock_addr, 0, sizeof(struct sockaddr_un));
    sock_addr.sun_family = AF_UNIX;
    strncpy(sock_addr.sun_path,
            socket_name,
            sizeof(sock_addr.sun_path)-1);

    while (connect(sock_fd,
                (const struct sockaddr*)&sock_addr,
                sizeof(struct sockaddr_un))) {
        if(wait_loop < 60) {
            if(!wait_loop)
                printf("Waiting for EGL stream producer ");
            else
                printf(".");
            fflush(stdout);
            sleep(1);
            wait_loop++;
        } else {
            printf("\n%s: Waiting timed out\n", __func__);
            return -1;
        }
    }
    if(wait_loop)
        printf("\n");

    if (1)
        printf("%s: Wait is done\n", __func__);

    return sock_fd;
}

/* Send <fd_to_send> (a file descriptor) to another process */
/* over a unix domain socket named <socket_name>.           */
/* <socket_name> can be any nonexistant filename.           */
static int EGLStreamSendfd(int send_fd, int fd_to_send)
{
    
    struct msghdr msg;
    struct iovec iov[1];
    char ctrl_buf[CMSG_SPACE(sizeof(int))];
    struct cmsghdr *cmsg = NULL;
    void *data;
    int res;
       memset(&msg, 0, sizeof(msg));

    iov[0].iov_len  = 1;    // must send at least 1 byte
    iov[0].iov_base = (void *)"x";  // any byte value (value ignored)
    msg.msg_iov = iov;
    msg.msg_iovlen = 1;

    memset(ctrl_buf, 0, sizeof(ctrl_buf));
    msg.msg_control = ctrl_buf;
    msg.msg_controllen = sizeof(ctrl_buf);

    cmsg = CMSG_FIRSTHDR(&msg);
    cmsg->cmsg_level = SOL_SOCKET;
    cmsg->cmsg_type = SCM_RIGHTS;
    cmsg->cmsg_len = CMSG_LEN(sizeof(int));
    data = CMSG_DATA(cmsg);
    *(int *)data = fd_to_send;

    msg.msg_controllen = cmsg->cmsg_len;

    res = sendmsg(send_fd, &msg, 0);
    if(res <= 0) {
        printf("%s: sendmsg failed", __func__);
        return -1;
    }

    return 0;
}

/* Listen on a unix domain socket named <socket_name>.     */
/* Connect to it and return connect_fd                     */
static int UnixSocketCreate(const char *socket_name)
{
    int listen_fd;
    struct sockaddr_un sock_addr;
    int connect_fd;
    struct sockaddr_un connect_addr;
    socklen_t connect_addr_len = 0;
    
    listen_fd = socket(PF_UNIX, SOCK_STREAM, 0);
    if (listen_fd < 0) {
        printf("%s: socket create failed", __func__);
        return -1;
    }

    if (1)
        printf("%s: listen_fd: %d\n", __func__, listen_fd);

    unlink(socket_name);

    memset(&sock_addr, 0, sizeof(struct sockaddr_un));
    sock_addr.sun_family = AF_UNIX;
    strncpy(sock_addr.sun_path,
            socket_name,
            sizeof(sock_addr.sun_path)-1);

    if (bind(listen_fd,
             (const struct sockaddr*)&sock_addr,
             sizeof(struct sockaddr_un))) {
        printf("i%s: bind error", __func__);
        return -1;
    }

    if (listen(listen_fd, 1)) {
        printf("%s: listen error", __func__);
        return -1;
    }

    connect_fd = accept(
                    listen_fd,
                    (struct sockaddr *)&connect_addr,
                    &connect_addr_len);

    if (1)
        printf("%s: connect_fd: %d\n", __func__, connect_fd);

    close(listen_fd);
    unlink(socket_name);
    if (connect_fd < 0) {
        printf("%s: accept failed\n", __func__);
        return -1;
    }

    return connect_fd;
}


/* receive a file descriptor from another process.         */
/* Returns the file descriptor.  Note: the integer value   */
/* of the file descriptor may be different from the        */
/* integer value in the other process, but the file        */
/* descriptors in each process will refer to the same file */
/* object in the kernel.                                   */
static int EGLStreamReceivefd(int connect_fd)
{
    struct msghdr msg;
    struct iovec iov[1];
    char msg_buf[1];
    char ctrl_buf[CMSG_SPACE(sizeof(int))];
    struct cmsghdr *cmsg;
    void *data;
    int recvfd;

   
    memset(&msg, 0, sizeof(msg));

    iov[0].iov_base = msg_buf;
    iov[0].iov_len  = sizeof(msg_buf);
    msg.msg_iov = iov;
    msg.msg_iovlen = 1;

    msg.msg_control = ctrl_buf;
    msg.msg_controllen = sizeof(ctrl_buf);

    if (recvmsg(connect_fd, &msg, 0) <= 0) {
        printf("%s: recvmsg failed\n", __func__);
        return -1;
    }

    cmsg = CMSG_FIRSTHDR(&msg);
    if (!cmsg) {
        printf("%s: NULL message header\n", __func__);
        return -1;
    }
    if (cmsg->cmsg_level != SOL_SOCKET) {
        printf("%s: Message level is not SOL_SOCKET\n", __func__);
        return -1;
    }
    if (cmsg->cmsg_type != SCM_RIGHTS) {
        printf("%s: Message type is not SCM_RIGHTS\n", __func__);
        return -1;
    }

    data = CMSG_DATA(cmsg);
    recvfd = *(int *)data;

    return recvfd;
}



/*******************************************************************************
 * Argus Producer thread:
 *   Opens the Argus camera driver, creates an OutputStream to output to a
 *   FrameConsumer, then performs repeating capture requests for CAPTURE_TIME
 *   seconds before closing the producer and Argus driver.
 ******************************************************************************/
static bool execute()
{
    // Initialize the preview window and EGL display.
    EGLDisplayHolder g_display;
    Window &window = Window::getInstance();
    window.setWindowRect(DEFAULT_WINDOW_RECT);
    PROPAGATE_ERROR(g_display.initialize(window.getEGLNativeDisplay()));
    // Create the CameraProvider object and get the core interface.
    UniqueObj<CameraProvider> cameraProvider = UniqueObj<CameraProvider>(CameraProvider::create());
    ICameraProvider *iCameraProvider = interface_cast<ICameraProvider>(cameraProvider);
    if (!iCameraProvider)
        ORIGINATE_ERROR("Failed to create CameraProvider");
    printf("Argus Version: %s\n", iCameraProvider->getVersion().c_str());

    // Get the selected camera device and sensor mode.
    CameraDevice* cameraDevice = ArgusHelpers::getCameraDevice(
            cameraProvider.get(),0);
    if (!cameraDevice)
        ORIGINATE_ERROR("Selected camera device is not available");
    SensorMode* sensorMode = ArgusHelpers::getSensorMode(cameraDevice,0);
    ISensorMode *iSensorMode = interface_cast<ISensorMode>(sensorMode);
    if (!iSensorMode)
        ORIGINATE_ERROR("Selected sensor mode not available");

    // Create the capture session using the selected device and get the core interface.
    UniqueObj<CaptureSession> captureSession(iCameraProvider->createCaptureSession(cameraDevice));
    ICaptureSession *iCaptureSession = interface_cast<ICaptureSession>(captureSession);
    if (!iCaptureSession)
        ORIGINATE_ERROR("Failed to get ICaptureSession interface");

    // Create the OutputStream.
    PRODUCER_PRINT("Creating output stream\n");
    UniqueObj<OutputStreamSettings> streamSettings(
        iCaptureSession->createOutputStreamSettings(STREAM_TYPE_EGL));
    IEGLOutputStreamSettings *iStreamSettings =
        interface_cast<IEGLOutputStreamSettings>(streamSettings);
    if (iStreamSettings)
    {
        iStreamSettings->setEGLDisplay(g_display.get());
        iStreamSettings->setPixelFormat(PIXEL_FMT_YCbCr_420_888);
        iStreamSettings->setResolution(iSensorMode->getResolution());
        iStreamSettings->setMode(EGL_STREAM_MODE_FIFO);
        iStreamSettings->setMetadataEnable(true);
    }
    UniqueObj<OutputStream> outputStream(iCaptureSession->createOutputStream(streamSettings.get()));
#if 0
    // Launch the FrameConsumer thread to consume frames from the OutputStream.
    PRODUCER_PRINT("Launching consumer thread\n");
    ConsumerThread frameConsumerThread(outputStream.get());
    PROPAGATE_ERROR(frameConsumerThread.initialize());

    // Wait until the consumer is connected to the stream.
    PROPAGATE_ERROR(frameConsumerThread.waitRunning());
#endif
#if 1
    IEGLOutputStream *iEGLOutputStream = interface_cast<IEGLOutputStream>(outputStream);
    if (!iEGLOutputStream)
        ORIGINATE_ERROR("Failed to create EGLOutputStream");
    if(iEGLOutputStream->getEGLDisplay() == EGL_NO_DISPLAY){
        fprintf(stderr, "Couldn't get display.\n");
    }
    if(iEGLOutputStream->getEGLStream() == EGL_NO_STREAM_KHR){
        fprintf(stderr, "Couldn't get KHR stream.\n");
    }

    fprintf(stderr, "###%d###.\n",__LINE__);
    EGLint state = 0;
    eglQueryStreamKHR(iEGLOutputStream->getEGLDisplay(),
                      iEGLOutputStream->getEGLStream(),
                      EGL_STREAM_STATE_KHR, &state);
    switch (state)
    {
    case EGL_STREAM_STATE_DISCONNECTED_KHR:
        fprintf(stderr, "EGL_STREAM_STATE_DISCONNECTED_KHR\n");
        break;
    case EGL_STREAM_STATE_EMPTY_KHR:
        fprintf(stderr, "EGL_STREAM_STATE_EMPTY_KHR\n");
        break;
    case EGL_STREAM_STATE_CONNECTING_KHR:
        fprintf(stderr, "EGL_STREAM_STATE_CONNECTING_KHR\n");
        break;
    case EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR:
        fprintf(stderr, "EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR\n");
        break;
    case EGL_STREAM_STATE_CREATED_KHR:
        fprintf(stderr, "EGL_STREAM_STATE_CREATED_KHR\n");
        break;
    default:
        fprintf(stderr, "GL_FALSE(0x%x)\n", state);
    }
    fprintf(stderr, "###%d###.\n",__LINE__);
    /*
    send_fd = UnixSocketConnect(SOCK_PATH);
    if (-1 == send_fd){
        printf("%s: Producer cannot create socket %s\n", __func__, SOCK_PATH);
        return false;
    }
        printf("%s: Producer success create socket %s\n", __func__, SOCK_PATH);
    */
    printf("%s: Producer start getStreamFileDescriptorKHR\n", __func__);
    fileDescriptor = eglGetStreamFileDescriptorKHR(iEGLOutputStream->getEGLDisplay(),
                                    /*EGLStreamKHR*/iEGLOutputStream->getEGLStream());
    fprintf(stderr, "###%d###.\n",__LINE__);
    if (EGL_NO_FILE_DESCRIPTOR_KHR == fileDescriptor) {
        printf("%s: Producer could not get EGL file descriptor.\n",__func__);
    }
        printf("%s: Producer get EGL file descriptor[%d]\n",__func__,fileDescriptor);
    int res = -1;
    res = EGLStreamSendfd(send_fd, fileDescriptor);   
    if (-1 == res) {
        printf("%s: Cuda Consumer could not send EGL file descriptor.\n", __func__);
        return false;
    }
        printf("%s: Cuda Consumer send EGL file descriptor[%d] success.\n", __func__,fileDescriptor);

#endif
    // Create capture request and enable output stream.
    UniqueObj<Request> request(iCaptureSession->createRequest());
    IRequest *iRequest = interface_cast<IRequest>(request);
    if (!iRequest)
        ORIGINATE_ERROR("Failed to create Request");
    iRequest->enableOutputStream(outputStream.get());

    // Set the sensor mode in the request.
    ISourceSettings *iSourceSettings = interface_cast<ISourceSettings>(request);
    if (!iSourceSettings)
        ORIGINATE_ERROR("Failed to get source settings request interface");
    iSourceSettings->setSensorMode(sensorMode);

    // Submit capture requests.
    PRODUCER_PRINT("Starting repeat capture requests.\n");
    if (iCaptureSession->repeat(request.get()) != STATUS_OK)
        ORIGINATE_ERROR("Failed to start repeat capture request");

    // Wait for specified number of seconds.
    sleep(5);

    // Stop the repeating request and wait for idle.
    iCaptureSession->stopRepeat();
    iCaptureSession->waitForIdle();

    // Destroy the output stream to end the consumer thread.
    outputStream.reset();

    // Wait for the consumer thread to complete.
    //PROPAGATE_ERROR(frameConsumerThread.shutdown());

    // Shut down Argus.
    cameraProvider.reset();

    PRODUCER_PRINT("Done -- exiting.\n");

    return true;
}

static bool execute1()
{
#if 1
    // Initialize the preview window and EGL display.
    EGLDisplayHolder g_display;
    Window &window = Window::getInstance();
    window.setWindowRect(DEFAULT_WINDOW_RECT);
    PROPAGATE_ERROR(g_display.initialize(window.getEGLNativeDisplay()));

    EGLStreamKHR consumerEglStream = EGL_NO_STREAM_KHR;    
    connect_fd = UnixSocketCreate(SOCK_PATH);
    if (-1 == connect_fd) {
        printf("%s: Consumer could not create socket: %s.\n",__func__, SOCK_PATH );
        return false;
    }
    fileDescriptor = EGLStreamReceivefd(connect_fd);
    if (-1 == fileDescriptor) {
        printf("%s: Consumer could not receive EGL file descriptor \n",__func__);
        return false;
    }
    consumerEglStream=eglCreateStreamFromFileDescriptorKHR(EGL_NO_DISPLAY,fileDescriptor);
    close(fileDescriptor);
    if (consumerEglStream == EGL_NO_STREAM_KHR) {
        printf("Consumer Could not create EGL stream.\n");
        return false;
    }
    // Launch the FrameConsumer thread to consume frames from the OutputStream.
    PRODUCER_PRINT("Launching consumer thread\n");
    //ConsumerThread frameConsumerThread(outputStream.get());
    //PROPAGATE_ERROR(frameConsumerThread.initialize());
    // Wait until the consumer is connected to the stream.
    //PROPAGATE_ERROR(frameConsumerThread.waitRunning());
    
    PreviewConsumerThread preview(g_display.get(),consumerEglStream);
    PROPAGATE_ERROR(preview.initialize());
    PROPAGATE_ERROR(preview.waitRunning());
    while(1)
    {
        sleep(1);
    }
    
#endif


}


}; // namespace ArgusSamples

int main(int argc, char** argv)
{
    if (!ArgusSamples::execute())
    //if (!ArgusSamples::execute1())
        return EXIT_FAILURE;

    return EXIT_SUCCESS;
}