videoSource.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
 
#ifndef __VIDEO_SOURCE_H_
#define __VIDEO_SOURCE_H_
 
 
#include "videoOptions.h"
#include "imageFormat.h"                
#include "commandLine.h"
 
 
#define VIDEO_SOURCE_USAGE_STRING  "videoSource arguments: \n"                                                          \
                  "    input                resource URI of the input stream, for example:\n"                   \
                  "                             * /dev/video0               (V4L2 camera #0)\n"                 \
                  "                             * csi://0                   (MIPI CSI camera #0)\n"             \
                  "                             * rtp://@:1234              (RTP stream)\n"                     \
                  "                             * rtsp://user:pass@ip:1234  (RTSP stream)\n"                    \
                  "                             * webrtc://@:1234/my_stream (WebRTC stream)\n"                  \
                  "                             * file://my_image.jpg       (image file)\n"                     \
                  "                             * file://my_video.mp4       (video file)\n"                     \
                  "                             * file://my_directory/      (directory of images)\n"            \
                  "  --input-width=WIDTH    explicitly request a width of the stream (optional)\n"      \
                  "  --input-height=HEIGHT  explicitly request a height of the stream (optional)\n"     \
                  "  --input-rate=RATE      explicitly request a framerate of the stream (optional)\n"  \
                  "  --input-save=FILE      path to video file for saving the input stream to disk\n"   \
                  "  --input-codec=CODEC    RTP requires the codec to be set, one of these:\n"                  \
                  "                             * h264, h265\n"                                                                 \
                  "                             * vp8, vp9\n"                                                                   \
                  "                             * mpeg2, mpeg4\n"                                                                       \
                  "                             * mjpeg\n"                                                                      \
                  "  --input-decoder=TYPE   the decoder engine to use, one of these:\n"                   \
                  "                             * cpu\n"                                                  \
                  "                             * omx  (aarch64/JetPack4 only)\n"                         \
                  "                             * v4l2 (aarch64/JetPack5 only)\n"                         \
                  "  --input-flip=FLIP      flip method to apply to input:\n"                                           \
                  "                             * none (default)\n"                                                             \
                  "                             * counterclockwise\n"                                                           \
                  "                             * rotate-180\n"                                                                         \
                  "                             * clockwise\n"                                                                  \
                  "                             * horizontal\n"                                                                         \
                  "                             * vertical\n"                                                                   \
                  "                             * upper-right-diagonal\n"                                                       \
                  "                             * upper-left-diagonal\n"                                                        \
                  "  --input-loop=LOOP      for file-based inputs, the number of loops to run:\n"               \
                  "                             * -1 = loop forever\n"                                                          \
                  "                             *  0 = don't loop (default)\n"                                          \
                  "                             * >0 = set number of loops\n\n"
 
 
class videoSource
{
public:
        enum Status
        {
                ERROR   = -2,   
                EOS     = -1,   
                TIMEOUT = 0,    
                OK      = 1     
        };
        
        static videoSource* Create( const videoOptions& options );
 
        static videoSource* Create( const char* URI, const videoOptions& options=videoOptions() );
 
        static videoSource* Create( const char* URI, const commandLine& cmdLine );
        
        static videoSource* Create( const char* URI, const int argc, char** argv );
 
        static videoSource* Create( const int argc, char** argv, int positionArg=-1 );
 
        static videoSource* Create( const commandLine& cmdLine, int positionArg=-1 );
        
        virtual ~videoSource();
 
        static inline const char* Usage()               { return VIDEO_SOURCE_USAGE_STRING; }
        
        template<typename T> bool Capture( T** image, int* status )                                                                             { return Capture((void**)image, imageFormatFromType<T>(), DEFAULT_TIMEOUT, status); }
        
        template<typename T> bool Capture( T** image, uint64_t timeout=DEFAULT_TIMEOUT, int* status=NULL )              { return Capture((void**)image, imageFormatFromType<T>(), timeout); }
        
        virtual bool Capture( void** image, imageFormat format, uint64_t timeout=DEFAULT_TIMEOUT, int* status=NULL ) = 0;
        
        virtual bool Open();
 
        virtual void Close();
 
        inline bool IsStreaming() const                         { return mStreaming; }
 
        inline uint32_t GetWidth() const                                { return mOptions.width; }
 
        inline uint32_t GetHeight() const                               { return mOptions.height; }
        
        inline uint32_t GetFrameRate() const                    { return mOptions.frameRate; }
 
        inline uint64_t GetFrameCount() const                   { return mOptions.frameCount; }
        
        uint64_t GetLastTimestamp() const { return mLastTimestamp; }
 
        inline imageFormat GetRawFormat() const { return mRawFormat; }
 
        inline const URI& GetResource() const                   { return mOptions.resource; }
 
        inline const videoOptions& GetOptions() const   { return mOptions; }
 
        virtual inline uint32_t GetType() const                 { return 0; }
 
        inline bool IsType( uint32_t type ) const               { return (type == GetType()); }
 
        template<typename T> bool IsType() const                { return IsType(T::Type); }
 
        inline const char* TypeToStr() const                    { return TypeToStr(GetType()); }
 
        static const char* TypeToStr( uint32_t type );
        
        static const uint64_t DEFAULT_TIMEOUT=1000;
 
protected:
        //videoSource();
        videoSource( const videoOptions& options );
 
        bool         mStreaming;
        videoOptions mOptions;
 
        uint64_t     mLastTimestamp;
        imageFormat  mRawFormat;
};
 
#endif