/*
 * Copyright (c) 2016-2022, 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 "Error.h"
#include "Thread.h"
#include "nvmmapi/NvNativeBuffer.h"
#include "ArgusHelpers.h"
#include <Argus/Ext/SensorTimestampTsc.h>

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

#include <Argus/Argus.h>
#include <NvVideoEncoder.h>
#include <NvApplicationProfiler.h>

#include "NvBufSurface.h"
#include "nvbuf_utils.h"
#include <opencv2/opencv.hpp>

#include <gst/gst.h>
#include <gst/app/gstappsrc.h>

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <fstream>
#include <chrono>
#include <thread>
#include <algorithm>

using namespace Argus;
using namespace EGLStream;

/* Constant configuration */
static const int    MAX_ENCODER_FRAMES = 5;
static const uint64_t WAIT_FOR_EVENT_TIMEOUT  = 1500000000;
static const uint64_t ACQUIRE_FRAME_TIMEOUT   = 3000000000;

/* This value is tricky.
   Too small value will impact the FPS */
static const int    NUM_BUFFERS        = 30;

/* Configurations which can be overrided by cmdline */
static std::string  OUTPUT_FILENAME ("output");
static std::string  CODEC ("H264");
static uint32_t     ENCODER_PIXFMT = V4L2_PIX_FMT_H264;
static uint32_t     CAPTURE_TIME = 5; // In seconds.
static uint32_t     SENSOR_MODE_INDEX = 0;
static uint8_t      BITRATE = 14;

static std::vector<uint64_t> cameraPTS;

/* Debug print macros */
#define PRODUCER_PRINT(...) printf("PRODUCER: " __VA_ARGS__)
#define CONSUMER_PRINT(...) printf("CONSUMER: " __VA_ARGS__)
#define CHECK_ERROR(expr) \
    do { \
        if ((expr) < 0) { \
            abort(); \
            ORIGINATE_ERROR(#expr " failed"); \
        } \
    } while (0);

static EGLDisplay   eglDisplay = EGL_NO_DISPLAY;

namespace ArgusSamples
{

/*******************************************************************************
 * Base Consumer thread:
 *   Creates an EGLStream::FrameConsumer object to read frames from the
 *   OutputStream, then creates/populates an NvBuffer (dmabuf) from the frames
 *   to be processed by processV4L2Fd.
 ******************************************************************************/
class ConsumerThread : public Thread
{
public:
    explicit ConsumerThread(OutputStream* stream, std::string outputName) :
        m_stream(stream),
        m_outputName(outputName),
        m_dmabuf(-1)
    {
        errorStatus = false;
    }
    bool errorStatus;
    ~ConsumerThread();

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

    bool createGstPipeline();
    void gstHandleMessage(GstElement * pipeline);
    bool gstFinishPipeline();

    GstElement *m_pipeline;
    GstElement *m_source;
    GstState m_state;
    uint32_t m_numFrames = 0;


    OutputStream* m_stream;
    std::string m_outputName;
    UniqueObj<FrameConsumer> m_consumer;
    int m_dmabuf;

private:
    void printErrorStatus(Argus::Status status);
};

void ConsumerThread::printErrorStatus(Argus::Status status)
{
    switch (status)
    {
        case Argus::STATUS_OK:
            CONSUMER_PRINT("Argus::STATUS_OK \n");
            break;
        case Argus::STATUS_INVALID_PARAMS:
            CONSUMER_PRINT("Argus::STATUS_INVALID_PARAMS \n");
            break;
        case Argus::STATUS_INVALID_SETTINGS:
            CONSUMER_PRINT("Argus::STATUS_INVALID_SETTINGS \n");
            break;
        case Argus::STATUS_UNAVAILABLE:
            CONSUMER_PRINT("Argus::STATUS_UNAVAILABLE \n");
            break;
        case Argus::STATUS_OUT_OF_MEMORY:
            CONSUMER_PRINT("Argus::STATUS_OUT_OF_MEMORY \n");
            break;
        case Argus::STATUS_UNIMPLEMENTED:
            CONSUMER_PRINT("Argus::STATUS_UNIMPLEMENTED \n");
            break;
        case Argus::STATUS_TIMEOUT:
            CONSUMER_PRINT("Argus::STATUS_TIMEOUT \n");
            break;
        case Argus::STATUS_CANCELLED:
            CONSUMER_PRINT("Argus::STATUS_CANCELLED \n");
            break;
        case Argus::STATUS_DISCONNECTED:
            CONSUMER_PRINT("Argus::STATUS_DISCONNECTED \n");
            break;
        case Argus::STATUS_END_OF_STREAM:
            CONSUMER_PRINT("Argus::STATUS_END_OF_STREAM \n");
            break;
        default:
            CONSUMER_PRINT("BAD STATUS \n");
            break;
    }
    return;
}

ConsumerThread::~ConsumerThread()
{
    if (m_dmabuf != -1)
        NvBufSurf::NvDestroy(m_dmabuf);
}

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


    if (!createGstPipeline())
        ORIGINATE_ERROR("Failed to create Gstreamer Pipeline");

    return true;
}

static void
notify_to_destroy (gpointer user_data)
{
    GST_INFO ("NvBufferDestroy(%d)", *(int *)user_data);
    NvBufferDestroy(*(int *)user_data);
    g_free(user_data);
}

bool ConsumerThread::threadExecute()
{
    IEGLOutputStream *iEglOutputStream = 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 (iEglOutputStream->waitUntilConnected() != STATUS_OK)
        ORIGINATE_ERROR("Stream failed to connect.");
    CONSUMER_PRINT("Producer has connected; continuing.\n");

    GstBuffer *buffer;
    GstFlowReturn ret;
    GstMapInfo map = {0};
    gpointer data = NULL, user_data = NULL;
    NvBufferParams par;
    GstMemoryFlags flags = (GstMemoryFlags)0;

    while (true)
    {
        Argus::Status argusStatus;

        /* Acquire a frame. */
        UniqueObj<Frame> frame(iFrameConsumer->acquireFrame(ACQUIRE_FRAME_TIMEOUT, &argusStatus));
        if (argusStatus != Argus::STATUS_OK)
        {
            printErrorStatus(argusStatus);
            errorStatus = true;
            break;
        }
        IFrame *iFrame = interface_cast<IFrame>(frame);
        if (!iFrame)
            break;

        /* Get the IImageNativeBuffer extension interface. */
        NV::IImageNativeBuffer *iNativeBuffer =
            interface_cast<NV::IImageNativeBuffer>(iFrame->getImage());
        if (!iNativeBuffer)
            ORIGINATE_ERROR("IImageNativeBuffer not supported by Image.");

        /* If we don't already have a buffer, create one from this image.
           Otherwise, just blit to our buffer. */
        if (m_dmabuf == -1)
        {
            m_dmabuf = iNativeBuffer->createNvBuffer(iEglOutputStream->getResolution(),
                                                     NVBUF_COLOR_FORMAT_RGBA,
                                                     NVBUF_LAYOUT_PITCH);
            if (m_dmabuf == -1)
                CONSUMER_PRINT("\tFailed to create NvBuffer\n");
        }
        else if (iNativeBuffer->copyToNvBuffer(m_dmabuf) != STATUS_OK)
        {
            ORIGINATE_ERROR("Failed to copy frame to NvBuffer.");
        }

        user_data = g_malloc(sizeof(int));
        GST_INFO ("NvBufferCreate %d", m_dmabuf);
        *(int *)user_data = m_dmabuf;
        NvBufferGetParams (m_dmabuf, &par);
        data = g_malloc(par.nv_buffer_size);

        GstClockTime duration = ((double)1/30) * GST_SECOND;
        GstClockTime timestamp = m_numFrames * duration;

        buffer = gst_buffer_new_wrapped_full(flags,
                                            data,
                                            par.nv_buffer_size,
                                            0,
                                            par.nv_buffer_size,
                                            user_data,
                                            notify_to_destroy);

        gst_buffer_map (buffer, &map, GST_MAP_WRITE);
        memcpy(map.data, par.nv_buffer , par.nv_buffer_size);
        gst_buffer_unmap(buffer, &map);


        GST_BUFFER_DURATION(buffer) = duration;
        GST_BUFFER_PTS(buffer) = timestamp;
        GST_BUFFER_DTS(buffer) = timestamp;
        GST_BUFFER_OFFSET(buffer) = m_numFrames;
        m_numFrames++;

        g_signal_emit_by_name(m_source, "push-buffer", buffer, &ret);

        if (ret != GST_FLOW_OK)
        {
            ORIGINATE_ERROR("Error pushing gstBuffer to GStreamer pipeline");
            return false;
        }

    }

    CONSUMER_PRINT("Done.\n");

    requestShutdown();

    return true;
}

bool ConsumerThread::threadShutdown()
{
    if (!gstFinishPipeline())
        ORIGINATE_ERROR("GStreamer pipeline coudln't finish properly");

    return true;
}

void ConsumerThread::gstHandleMessage(GstElement * pipeline)
{
    GstBus *bus;
    GstStreamStatusType tp;
    GstElement * elem = NULL;

    bus = gst_element_get_bus(pipeline);

    while (gst_bus_have_pending(bus))
    {
        GstMessage *msg;
        msg = gst_bus_pop(bus);
        if (!msg || !GST_IS_MESSAGE(msg))
            continue;
        else
        {
            switch (GST_MESSAGE_TYPE (msg)) {
            case GST_MESSAGE_STATE_CHANGED:
                GstState oldstate, newstate, pendstate;
                gst_message_parse_state_changed(msg, &oldstate, &newstate, &pendstate);
                break;
            case GST_MESSAGE_ERROR:
            {
                GError *err;
                gchar *debug;
                gst_message_parse_error(msg, &err, &debug);
                gchar *name;
                name = gst_element_get_name(GST_MESSAGE_SRC (msg));
                std::cout << "Embedded video playback halted; module " << name <<
                        " reported: " << (err ? err->message : "<unknown reason>") << std::endl;
                gst_element_set_state(GST_ELEMENT(pipeline), GST_STATE_NULL);
                break;
            }
            case GST_MESSAGE_EOS:
                break;
            case GST_MESSAGE_STREAM_STATUS:
                gst_message_parse_stream_status(msg,&tp,&elem);
                break;
            default:
                break;
            }
        }
    }
}

bool ConsumerThread::gstFinishPipeline()
{
    GstStateChangeReturn status;
    if (m_pipeline)
    {
        gstHandleMessage(m_pipeline);

        if (!(bool)m_source)
        {
            ORIGINATE_ERROR("No source in GStreamer pipeline. Ignore");
        }
        else if (gst_app_src_end_of_stream(GST_APP_SRC(m_source)) != GST_FLOW_OK)
        {
            ORIGINATE_ERROR("Cannot send EOS to GStreamer pipeline");
        }
        else
        {
            //wait for EOS to trickle down the pipeline. This will let all elements finish properly
            GstBus *bus;
            bus = gst_element_get_bus(m_pipeline);
            if (bus)
            {
                GstMessage *msg;
                msg = gst_bus_timed_pop_filtered(bus, GST_CLOCK_TIME_NONE, (GstMessageType)(GST_MESSAGE_ERROR | GST_MESSAGE_EOS));
                if (!msg || GST_MESSAGE_TYPE(msg) == GST_MESSAGE_ERROR)
                {
                    ORIGINATE_ERROR("Error during VideoWriter finalization");
                    gstHandleMessage(m_pipeline);
                }
            }
            else
            {
                ORIGINATE_ERROR("can't get GstBus");
            }
        }

        status = gst_element_set_state (m_pipeline, GST_STATE_NULL);
        if (status == GST_STATE_CHANGE_ASYNC)
        {
            // wait for status update
            GstState st1;
            GstState st2;
            status = gst_element_get_state(m_pipeline, &st1, &st2, GST_CLOCK_TIME_NONE);
        }
        if (status == GST_STATE_CHANGE_FAILURE)
        {
            gstHandleMessage (m_pipeline);
            ORIGINATE_ERROR("Unable to stop writer pipeline");
        }
    }
    return true;
}

bool ConsumerThread::createGstPipeline()
{
    std::string pipelineString = "appsrc name=src ! video/x-raw(memory:NVMM), width=3840, height=2160, framerate=30/1, format=RGBA ! nvvidconv ! video/x-raw(memory:NVMM), format=NV12 ! nvv4l2h264enc ! h264parse ! mp4mux ! filesink location=" + m_outputName;
    std::cout << "Gstreamer pipeline: " << pipelineString << std::endl;
    m_pipeline = gst_parse_launch(pipelineString.c_str(), NULL);
    if (!m_pipeline)
        ORIGINATE_ERROR("Failed to create video pipeline");

    m_source = gst_bin_get_by_name(GST_BIN(m_pipeline), "src");
    if (!m_source)
        ORIGINATE_ERROR("Failed to get pipeline source pipeline");

    if (!m_pipeline || !m_source)
        ORIGINATE_ERROR("Video encoder not initialized");

    // Start the pipeline.
    if (gst_element_set_state(m_pipeline, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE)
        ORIGINATE_ERROR("Failed to start recording.");

    m_state = GST_STATE_PLAYING;

    return true;
}

/**
 * Argus Producer thread:
 *   Opens the Argus camera driver, creates an BufferOutputStream to output
 *   frames, then performs repeating capture requests for CAPTURE_TIME
 *   seconds before closing the producer and Argus driver.
 */
static bool execute()
{
    /* Create the CameraProvider object and get the core interface */
    UniqueObj<CameraProvider> cameraProvider = UniqueObj<CameraProvider>(CameraProvider::create());
    // Get the ICameraProvider interface from the global CameraProvider.
    ICameraProvider *iCameraProvider = interface_cast<ICameraProvider>(cameraProvider);
    if (!iCameraProvider)
        ORIGINATE_ERROR("Failed to get ICameraProvider interface");
    printf("Argus Version: %s\n", iCameraProvider->getVersion().c_str());

    // Get the camera devices.
    std::vector<CameraDevice*> cameraDevices;
    iCameraProvider->getCameraDevices(&cameraDevices);
    if (cameraDevices.size() < 2)
        ORIGINATE_ERROR("Must have at least 2 sensors available");

    std::vector <CameraDevice*> lrCameras;
    lrCameras.push_back(cameraDevices[0]); // Left Camera (the 1st camera will be used for AC)
    lrCameras.push_back(cameraDevices[1]); // Right Camera

    // Create the capture session, AutoControl will be based on what the 1st device sees.
    UniqueObj<CaptureSession> captureSession(iCameraProvider->createCaptureSession(lrCameras));
    ICaptureSession *iCaptureSession = interface_cast<ICaptureSession>(captureSession);
    if (!iCaptureSession)
        ORIGINATE_ERROR("Failed to get capture session interface");


    SensorMode* sensorMode = ArgusHelpers::getSensorMode(lrCameras[0], SENSOR_MODE_INDEX);
    ISensorMode *iSensorMode = interface_cast<ISensorMode>(sensorMode);
    if (!iSensorMode)
        ORIGINATE_ERROR("Selected sensor mode not available");
    Size2D<uint32_t> sensorResolution = iSensorMode->getResolution();
    std::cout << "Sensor mode: " << SENSOR_MODE_INDEX << "  width: " << sensorResolution.width() << "  height: " << sensorResolution.height() << std::endl;

    uint32_t framerate = (1000000000 / (iSensorMode->getFrameDurationRange().min() - 1));
    std::cout << "Framerate: " << framerate << std::endl;

    // Create stream settings object and set settings common to both streams.
    UniqueObj<OutputStreamSettings> streamSettings(
        iCaptureSession->createOutputStreamSettings(STREAM_TYPE_EGL));
    IOutputStreamSettings *iStreamSettings = interface_cast<IOutputStreamSettings>(streamSettings);
    IEGLOutputStreamSettings *iEGLStreamSettings =
        interface_cast<IEGLOutputStreamSettings>(streamSettings);
    if (!iStreamSettings || !iEGLStreamSettings)
        ORIGINATE_ERROR("Failed to create OutputStreamSettings");
    iEGLStreamSettings->setPixelFormat(PIXEL_FMT_YCbCr_420_888);
    iEGLStreamSettings->setResolution(sensorResolution);
    iEGLStreamSettings->setEGLDisplay(eglDisplay);


    // Create egl streams
    PRODUCER_PRINT("Creating left stream.\n");
    iStreamSettings->setCameraDevice(lrCameras[0]);
    UniqueObj<OutputStream> streamLeft(iCaptureSession->createOutputStream(streamSettings.get()));
    IEGLOutputStream *iStreamLeft = interface_cast<IEGLOutputStream>(streamLeft);
    if (!iStreamLeft)
        ORIGINATE_ERROR("Failed to create left stream");

    PRODUCER_PRINT("Creating right stream.\n");
    iStreamSettings->setCameraDevice(lrCameras[1]);
    UniqueObj<OutputStream> streamRight(iCaptureSession->createOutputStream(streamSettings.get()));
    IEGLOutputStream *iStreamRight = interface_cast<IEGLOutputStream>(streamRight);
    if (!iStreamRight)
        ORIGINATE_ERROR("Failed to create right stream");


    /* Launch the FrameConsumer thread to consume frames from the OutputStream */
    PRODUCER_PRINT("Launching consumer thread\n");
    ConsumerThread previewConsumerThreadLeft(streamLeft.get(), OUTPUT_FILENAME + "-0.mp4");
    ConsumerThread previewConsumerThreadRight(streamRight.get(), OUTPUT_FILENAME + "-1.mp4");

    PROPAGATE_ERROR(previewConsumerThreadLeft.initialize());
    PROPAGATE_ERROR(previewConsumerThreadRight.initialize());
    
    PROPAGATE_ERROR(previewConsumerThreadLeft.waitRunning());
    PROPAGATE_ERROR(previewConsumerThreadRight.waitRunning());


    /* 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(streamLeft.get());
    iRequest->enableOutputStream(streamRight.get());


    ISourceSettings *iSourceSettings = interface_cast<ISourceSettings>(iRequest->getSourceSettings());
    if (!iSourceSettings)
        ORIGINATE_ERROR("Failed to get ISourceSettings interface");
    iSourceSettings->setSensorMode(sensorMode);
    iSourceSettings->setFrameDurationRange(1000000000 / (framerate + 1));

    // Set the denoise settings.
    IDenoiseSettings *denoiseSettings = interface_cast<IDenoiseSettings>(request);
    if (!denoiseSettings)
        ORIGINATE_ERROR("Failed to get DenoiseSettings interface");
    denoiseSettings->setDenoiseMode(DENOISE_MODE_FAST);
    denoiseSettings->setDenoiseStrength(1.0f);

    /* 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");


    IEventProvider *iEventProvider = interface_cast<IEventProvider>(captureSession);

    std::vector<EventType> eventTypes;
    eventTypes.push_back(EVENT_TYPE_CAPTURE_COMPLETE);
    eventTypes.push_back(EVENT_TYPE_ERROR);
    eventTypes.push_back(EVENT_TYPE_CAPTURE_STARTED);
    UniqueObj<EventQueue> queue(iEventProvider->createEventQueue(eventTypes));
    IEventQueue *iQueue = interface_cast<IEventQueue>(queue);

    if (!iEventProvider || !iQueue)
        ORIGINATE_ERROR("event");

    const uint64_t FIVE_SECONDS = 5000000000;


    auto startTime = std::chrono::high_resolution_clock::now();
    while (true)
    {
        iEventProvider->waitForEvents(queue.get(), FIVE_SECONDS);

        const Event* event = iQueue->getEvent(0);
        const IEvent* iEvent = interface_cast<const IEvent>(event);
        if (!iEvent)
            printf("Error : Failed to get IEvent interface\n");
        else
        {
            if (iEvent->getEventType() == EVENT_TYPE_CAPTURE_COMPLETE)
                {
                const IEventCaptureComplete* iEventCaptureComplete
                    = interface_cast<const IEventCaptureComplete>(event);
                if (!iEventCaptureComplete)
                    ORIGINATE_ERROR("Failed to get EventCaptureComplete Interface");

                const CaptureMetadata* metaData = iEventCaptureComplete->getMetadata();
                const ICaptureMetadata* iMetadata = interface_cast<const ICaptureMetadata>(metaData);
                if (!iMetadata)
                    ORIGINATE_ERROR("Failed to get CaptureMetadata Interface");
                const Ext::ISensorTimestampTsc *iSensorTimestampTsc = interface_cast<const Ext::ISensorTimestampTsc>(metaData);
                if (iSensorTimestampTsc)
                {
                        // printf("sof= %lu, eof= %lu\n",
                        //         iSensorTimestampTsc->getSensorSofTimestampTsc(),
                        //         iSensorTimestampTsc->getSensorEofTimestampTsc());
                        cameraPTS.push_back(iSensorTimestampTsc->getSensorEofTimestampTsc());
                }
            }
            else if (iEvent->getEventType() == EVENT_TYPE_CAPTURE_STARTED)
                printf("started\n");
            else if (iEvent->getEventType() == EVENT_TYPE_ERROR)
                printf("error\n");
        }
        auto currentTime = std::chrono::high_resolution_clock::now();
        auto elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(currentTime - startTime).count();
        if (elapsedTime/1000 > CAPTURE_TIME)
            break;
    }

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


    // Disconnect Argus producer from the EGLStreams (and unblock consumer acquire).
    PRODUCER_PRINT("Captures complete, disconnecting producer.\n");
    iStreamLeft->disconnect();
    iStreamRight->disconnect();

    /* Destroy the output stream to end the consumer thread */
    streamLeft.reset();
    streamRight.reset();

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

    return true;
}

}; /* namespace ArgusSamples */


static void printHelp()
{
    printf("Usage: camera_recording [OPTIONS]\n"
           "Options:\n"
           "  -f        Set output filename [Default output-#.mp4]\n"
           "  -t        Set encoder type H264 or H265 [Default H264]\n"
           "  -d        Set capture duration [Default 5 seconds]\n"
           "  -m        Set sensor mode of the cameras [Default 0]\n"
           "  -h        Print this help\n");
}

static bool parseCmdline(int argc, char **argv)
{
    int c;
    while ((c = getopt(argc, argv, "m:f:d:c:b:")) != -1)
    {
        switch (c)
        {
            case 'm':
                SENSOR_MODE_INDEX = atoi(optarg);
                break;
            case 'f':
                OUTPUT_FILENAME = optarg;
                break;
            case 'c':
                if (strcmp(optarg, "H264") == 0)
                    ENCODER_PIXFMT = V4L2_PIX_FMT_H264;
                else if (strcmp(optarg, "H265") == 0)
                    ENCODER_PIXFMT = V4L2_PIX_FMT_H265;
                else if (strcmp(optarg, "AV1") == 0)
                    ENCODER_PIXFMT = V4L2_PIX_FMT_AV1;
                else
                    ORIGINATE_ERROR("Codec is not supported!");
                CODEC = optarg;
                std::transform(CODEC.begin(), CODEC.end(), CODEC.begin(),
                                [](unsigned char c){ return std::tolower(c); }); // lower codec string
                break;
            case 'b':
                BITRATE = atoi(optarg);
                break;
            case 'd':
                CAPTURE_TIME = atoi(optarg);
                break;
            default:
                return false;
        }
    }
    return true;
}

int main(int argc, char *argv[])
{
    if (!parseCmdline(argc, argv))
    {
        printHelp();
        return EXIT_FAILURE;
    }
    gst_init(&argc, &argv);

    NvApplicationProfiler &profiler = NvApplicationProfiler::getProfilerInstance();

    /* Get default EGL display */
    eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
    if (eglDisplay == EGL_NO_DISPLAY)
    {
        printf("Cannot get EGL display.\n");
        return EXIT_FAILURE;
    }

    if (!ArgusSamples::execute())
        return EXIT_FAILURE;

    /* Terminate EGL display */
    eglTerminate(eglDisplay);

    profiler.stop();
    profiler.printProfilerData(std::cout);

    return EXIT_SUCCESS;
}