Do some InputReader cleanup

1 files changed, 64 insertions, 86 deletions

diff --git a/src/InputReader.h b/src/InputReader.h
index 7d6b373..c897c2d 100644
--- a/src/InputReader.h
+++ b/src/InputReader.h
@@ -3,7 +3,7 @@
    Her Majesty the Queen in Right of Canada (Communications Research
    Center Canada)
 
-   Copyright (C) 2016
+   Copyright (C) 2018
    Matthias P. Braendli, matthias.braendli@mpb.li
 
     http://www.opendigitalradio.org
@@ -33,6 +33,7 @@
 
 #include <cstdio>
 #include <vector>
+#include <atomic>
 #include <memory>
 #if defined(HAVE_ZEROMQ)
 #  include "zmq.hpp"
@@ -40,47 +41,8 @@
 #endif
 #include "porting.h"
 #include "Log.h"
-#include "lib/UdpSocket.h"
-#include <sys/socket.h>
-#include <netinet/in.h>
 #include <unistd.h>
-#include <netdb.h>
-#include <arpa/inet.h>
-#define SOCKET           int
 #define INVALID_SOCKET   -1
-#define SOCKET_ERROR     -1
-
-/* Known types of input streams. Description taken from the CRC mmbTools forum.
-
-    All numbers are little-endian.
-
-    Framed format is used for file recording. It is the default format. The
-    padding can be removed from data. Format:
-        uint32_t nbFrames
-        for each frame
-          uint16_t frameSize
-          uint8_t data[frameSize]
-
-    Streamed format is used for streamed applications. As the total number of
-    frames is unknown before end of transmission, the corresponding field is
-    removed. The padding can be removed from data. Format:
-        for each frame
-          uint16_t frameSize
-          uint8_t data[frameSize]
-
-    Raw format is a bit-by-bit (but byte aligned on sync) recording of a G.703
-    data stream. The padding is always present. Format:
-        for each frame
-          uint8_t data[6144]
-
-    Please note that our raw format can also be referred to as ETI(NI, G.703) or ETI(NI).
-*/
-enum EtiStreamType {
-    ETI_STREAM_TYPE_NONE = 0,
-    ETI_STREAM_TYPE_RAW,
-    ETI_STREAM_TYPE_STREAMED,
-    ETI_STREAM_TYPE_FRAMED,
-};
 
 class InputReader
 {
@@ -91,43 +53,25 @@ class InputReader
         virtual int GetNextFrame(void* buffer) = 0;
 
         // Print some information
-        virtual void PrintInfo() = 0;
+        virtual void PrintInfo() const = 0;
 };
 
 class InputFileReader : public InputReader
 {
     public:
-        InputFileReader() :
-            streamtype_(ETI_STREAM_TYPE_NONE),
-            inputfile_(NULL) { }
-
-        ~InputFileReader()
-        {
-            if (inputfile_ != NULL) {
-                fprintf(stderr, "\nClosing input file...\n");
-
-                fclose(inputfile_);
-            }
-        }
+        InputFileReader() = default;
+        InputFileReader(const InputFileReader& other) = delete;
+        InputFileReader& operator=(const InputFileReader& other) = delete;
 
         // open file and determine stream type
         // When loop=1, GetNextFrame will never return 0
         int Open(std::string filename, bool loop);
 
         // Print information about the file opened
-        void PrintInfo();
-
+        void PrintInfo() const;
         int GetNextFrame(void* buffer);
 
-        EtiStreamType GetStreamType()
-        {
-            return streamtype_;
-        }
-
     private:
-        InputFileReader(const InputFileReader& other) = delete;
-        InputFileReader& operator=(const InputFileReader& other) = delete;
-
         int IdentifyType();
 
         // Rewind the file, and replay anew
@@ -136,19 +80,60 @@ class InputFileReader : public InputReader
 
         bool loop_; // if shall we loop the file over and over
         std::string filename_;
-        EtiStreamType streamtype_;
-        FILE* inputfile_;
 
-        size_t inputfilelength_;
-        uint64_t nbframes_; // 64-bit because 32-bit overflow is
-                            // after 2**32 * 24ms ~= 3.3 years
+        /* Known types of input streams. Description taken from the CRC
+         * mmbTools forum. All values are are little-endian.  */
+        enum class EtiStreamType {
+            /* Not yet identified */
+            None,
+
+            /* Raw format is a bit-by-bit (but byte aligned on sync) recording
+             * of a G.703 data stream. The padding is always present.
+             * The raw format can also be referred to as ETI(NI, G.703) or ETI(NI).
+             * Format:
+                 for each frame:
+                   uint8_t data[6144]
+             */
+            Raw,
+
+            /* Streamed format is used for streamed applications. As the total
+             * number of frames is unknown before end of transmission, the
+             * corresponding field is removed. The padding can be removed from
+             * data.
+             * Format:
+                 for each frame:
+                   uint16_t frameSize
+                   uint8_t data[frameSize]
+             */
+            Streamed,
+
+            /* Framed format is used for file recording. It is the default format.
+             * The padding can be removed from data.
+             * Format:
+                 uint32_t nbFrames
+                 for each frame:
+                   uint16_t frameSize
+                   uint8_t data[frameSize]
+             */
+            Framed,
+        };
+
+        EtiStreamType streamtype_ = EtiStreamType::None;
+        struct FILEDeleter{ void operator()(FILE* fd){ if(fd) fclose(fd);}};
+        std::unique_ptr<FILE, FILEDeleter> inputfile_;
+
+        size_t inputfilelength_ = 0;
+        uint64_t nbframes_ = 0; // 64-bit because 32-bit overflow is
+        // after 2**32 * 24ms ~= 3.3 years
 };
 
 class InputTcpReader : public InputReader
 {
     public:
         InputTcpReader();
-        ~InputTcpReader();
+        InputTcpReader(const InputTcpReader& other) = delete;
+        InputTcpReader& operator=(const InputTcpReader& other) = delete;
+        virtual ~InputTcpReader();
 
         // Endpoint is either host:port or tcp://host:port
         void Open(const std::string& endpoint);
@@ -159,21 +144,19 @@ class InputTcpReader : public InputReader
         virtual int GetNextFrame(void* buffer);
 
         // Print some information
-        virtual void PrintInfo();
+        virtual void PrintInfo() const;
 
     private:
-        InputTcpReader(const InputTcpReader& other) = delete;
-        InputTcpReader& operator=(const InputTcpReader& other) = delete;
-        SOCKET m_sock;
+        int m_sock = INVALID_SOCKET;
         std::string m_uri;
 };
 
 struct zmq_input_overflow : public std::exception
 {
-  const char* what () const throw ()
-  {
-    return "InputZMQ buffer overflow";
-  }
+    const char* what () const throw ()
+    {
+        return "InputZMQ buffer overflow";
+    }
 };
 
 #if defined(HAVE_ZEROMQ)
@@ -189,17 +172,12 @@ struct InputZeroMQThreadData
 class InputZeroMQWorker
 {
     public:
-        InputZeroMQWorker() :
-            running(false),
-            zmqcontext(1),
-            m_to_drop(0) { }
-
         void Start(struct InputZeroMQThreadData* workerdata);
         void Stop();
+        bool is_running(void) const { return running; }
 
-        bool is_running(void) { return running; }
     private:
-        bool running;
+        std::atomic<bool> running = ATOMIC_VAR_INIT(false);
 
         void RecvProcess(struct InputZeroMQThreadData* workerdata);
 
@@ -212,7 +190,7 @@ class InputZeroMQWorker
          *
          * Here we keep track of how many ETI frames we must drop
          */
-        int m_to_drop;
+        int m_to_drop = 0;
 };
 
 class InputZeroMQReader : public InputReader
@@ -232,7 +210,7 @@ class InputZeroMQReader : public InputReader
 
         int GetNextFrame(void* buffer);
 
-        void PrintInfo();
+        void PrintInfo() const;
 
     private:
         InputZeroMQReader(const InputZeroMQReader& other) = delete;