slsDetectorPackage/slsReceiverSoftware/include/slsReceiverTCPIPInterface.h

#pragma once
/********************************************/ /**
                                                * @file
                                                *slsReceiverTCPIPInterface.h
                                                * @short interface between
                                                *receiver and client
                                                ***********************************************/

#include "receiver_defs.h"
#include "sls_detector_defs.h"

class MySocketTCP;
class ServerInterface;
#include "ServerSocket.h"
#include "slsReceiverImplementation.h"

/**
 *@short interface between receiver and client
 */

class slsReceiverTCPIPInterface : private virtual slsDetectorDefs {
  private:
    enum numberMode { DEC, HEX };

  public:
    /** Destructor */
    virtual ~slsReceiverTCPIPInterface();

    /**
     * Constructor
     * reads config file, creates socket, assigns function table
     * throws an exception in case of failure to construct
     * @param pn port number (defaults to default port number)
     */

    slsReceiverTCPIPInterface(int pn = -1);

    /**
     * Starts listening on the TCP port for client comminication
     \returns OK or FAIL
     */
    int start();

    /** stop listening on the TCP & UDP port for client comminication */
    void stop();

    /** gets version */
    int64_t getReceiverVersion();

    //***callback functions***
    /**
     * Call back for start acquisition
     * callback arguments are
     * filepath
     * filename
     * fileindex
     * datasize
     *
     * return value is insignificant at the moment
     * we write depending on file write enable
     * users get data to write depending on call backs registered
     */
    void registerCallBackStartAcquisition(int (*func)(char *, char *, uint64_t,
                                                      uint32_t, void *),
                                          void *arg);

    /**
     * Call back for acquisition finished
     * callback argument is
     * total frames caught
     */
    void registerCallBackAcquisitionFinished(void (*func)(uint64_t, void *),
                                             void *arg);

    /**
     * Call back for raw data
     * args to raw data ready callback are
     * sls_receiver_header frame metadata
     * dataPointer is the pointer to the data
     * dataSize in bytes is the size of the data in bytes.
     */
    void registerCallBackRawDataReady(void (*func)(char *, char *, uint32_t,
                                                   void *),
                                      void *arg);

    /**
     * Call back for raw data (modified)
     * args to raw data ready callback are
     * sls_receiver_header frame metadata
     * dataPointer is the pointer to the data
     * revDatasize is the reference of data size in bytes.
     * Can be modified to the new size to be written/streamed. (only smaller
     * value).
     */
    void registerCallBackRawDataModifyReady(void (*func)(char *, char *,
                                                         uint32_t &, void *),
                                            void *arg);

  private:
    /**
     * Static function - Thread started which is a TCP server
     * Called by start()
     * @param this_pointer pointer to this object
     */
    static void *startTCPServerThread(void *this_pointer);

    /**
     * Thread started which is a TCP server
     * Called by start()
     */
    void startTCPServer();

    /** assigns functions to the fnum enum */
    int function_table();

    /** Decodes Function */
    int decode_function(sls::ServerInterface2 &socket);

    /** function not implemented for specific detector */
    void functionNotImplemented();

    /** mode not implemented for specific detector */
    void modeNotImplemented(const std::string& modename, int mode);

    /** validate and set error */
    template <typename T>
    void validate(T arg, T retval, std::string modename, numberMode hex);

    /** Execute command */
    int exec_command(sls::ServerInterface2 &socket);

    /** Exit Receiver Server */
    int exit_server(sls::ServerInterface2 &socket);

    /** Locks Receiver */
    int lock_receiver(sls::ServerInterface2 &socket);

    /** Get Last Client IP*/
    int get_last_client_ip(sls::ServerInterface2 &socket);

    /** Set port */
    int set_port(sls::ServerInterface2 &socket);

    /** Updates Client if different clients connect */
    int update_client(sls::ServerInterface2 &socket);

    /** Sends the updated parameters to client */
    int send_update(sls::ServerInterface2 &socket);

    /** get version, calls get_version */
    int get_id(sls::ServerInterface2 &socket);

    /** Set detector type */
    int set_detector_type(sls::ServerInterface2 &socket);

    /** set detector hostname  */
    int set_detector_hostname(sls::ServerInterface2 &socket);

    /** set roi */
    int set_roi(sls::ServerInterface2 &socket);

    /** Set up UDP Details */
    int setup_udp(sls::ServerInterface2 &socket);

    /** set acquisition period, frame number etc */
    int set_timer(sls::ServerInterface2 &socket);

    /** set dynamic range  */
    int set_dynamic_range(sls::ServerInterface2 &socket);

    /** Sets the receiver streaming frequency */
    int set_streaming_frequency(sls::ServerInterface2 &socket);

    /** Gets receiver status */
    int get_status(sls::ServerInterface2 &socket);

    /** Start Receiver - starts listening to udp packets from detector */
    int start_receiver(sls::ServerInterface2 &socket);

    /** Stop Receiver - stops listening to udp packets from detector*/
    int stop_receiver(sls::ServerInterface2 &socket);

    /** Set File path */
    int set_file_dir(sls::ServerInterface2 &socket);

    /** Set File name without frame index, file index and extension */
    int set_file_name(sls::ServerInterface2 &socket);

    /** Set File index */
    int set_file_index(sls::ServerInterface2 &socket);

    /** Gets frame index for each acquisition */
    int get_frame_index(sls::ServerInterface2 &socket);

    /** Gets Total Frames Caught */
    int get_frames_caught(sls::ServerInterface2 &socket);

    /** Resets Total Frames Caught */
    int reset_frames_caught(sls::ServerInterface2 &socket);

    /** Enable File Write*/
    int enable_file_write(sls::ServerInterface2 &socket);

    /** Enable Master File Write */
    int enable_master_file_write(sls::ServerInterface2 &socket);

    /** enable compression */
    int enable_compression(sls::ServerInterface2 &socket);

    /** enable overwrite  */
    int enable_overwrite(sls::ServerInterface2 &socket);

    /** enable 10Gbe */
    int enable_tengiga(sls::ServerInterface2 &socket);

    /** set fifo depth */
    int set_fifo_depth(sls::ServerInterface2 &socket);

    /** activate/ deactivate */
    int set_activate(sls::ServerInterface2 &socket);

    /* Set the data stream enable */
    int set_data_stream_enable(sls::ServerInterface2 &socket);

    /** Sets the steadming timer when frequency is set to 0 */
    int set_streaming_timer(sls::ServerInterface2 &socket);

    /** enable flipped data */
    int set_flipped_data(sls::ServerInterface2 &socket);

    /** set file format */
    int set_file_format(sls::ServerInterface2 &socket);

    /** set position id */
    int set_detector_posid(sls::ServerInterface2 &socket);

    /** set multi detector size */
    int set_multi_detector_size(sls::ServerInterface2 &socket);

    /** set streaming port */
    int set_streaming_port(sls::ServerInterface2 &socket);

    /** set streaming source ip */
    int set_streaming_source_ip(sls::ServerInterface2 &socket);

    /** set silent mode */
    int set_silent_mode(sls::ServerInterface2 &socket);

    /** enable gap pixels */
    int enable_gap_pixels(sls::ServerInterface2 &socket);

    /** restream stop packet */
    int restream_stop(sls::ServerInterface2 &socket);

    /** set additional json header */
    int set_additional_json_header(sls::ServerInterface2 &socket);

    /** get additional json header */
    int get_additional_json_header(sls::ServerInterface2 &socket);

    /** set udp socket buffer size */
    int set_udp_socket_buffer_size(sls::ServerInterface2 &socket);

    /** get real udp socket buffer size */
    int get_real_udp_socket_buffer_size(sls::ServerInterface2 &socket);

    /** set frames per file */
    int set_frames_per_file(sls::ServerInterface2 &socket);

    /** check version compatibility */
    int check_version_compatibility(sls::ServerInterface2 &socket);

    /** set frame discard policy */
    int set_discard_policy(sls::ServerInterface2 &socket);

    /** set partial frame padding enable*/
    int set_padding_enable(sls::ServerInterface2 &socket);

    /** set deactivated receiver padding enable */
    int set_deactivated_padding_enable(sls::ServerInterface2 &socket);

    /** set readout flags */
    int set_readout_flags(sls::ServerInterface2 &socket);

    /** set adc mask */
    int set_adc_mask(sls::ServerInterface2 &socket);

    /** set receiver dbit list */
    int set_dbit_list(sls::ServerInterface2 &socket);

    /** get receiver dbit list */
    int get_dbit_list(sls::ServerInterface2 &socket);

    /** set dbit offset */
    int set_dbit_offset(sls::ServerInterface2 &socket);

    /** quad type */
    int set_quad_type(sls::ServerInterface2 &socket);

    /** detector type */
    detectorType myDetectorType;

    /** slsReceiverBase object */
    std::unique_ptr<slsReceiverImplementation> receiver{nullptr};

    /** Function List */
    int (slsReceiverTCPIPInterface::*flist[NUM_REC_FUNCTIONS])(
        sls::ServerInterface2 &socket);

    /** Message */
    char mess[MAX_STR_LENGTH]{};

    /** success/failure */
    int ret{OK};

    /** function index */
    int fnum{-1};

    /** Lock Status if server locked to a client */
    int lockStatus{0};

    /** kill tcp server thread */
    int killTCPServerThread{0};

    /** thread for TCP server */
    pthread_t TCPServer_thread;

    /** tcp thread created flag*/
    bool tcpThreadCreated{false};

    /** port number */
    int portNumber;

    //***callback parameters***
    /**
     * Call back for start acquisition
     * callback arguments are
     * filepath
     * filename
     * fileindex
     * datasize
     *
     * return value is insignificant at the moment
     * we write depending on file write enable
     * users get data to write depending on call backs registered
     */
    int (*startAcquisitionCallBack)(char *, char *, uint64_t, uint32_t,
                                    void *) = nullptr;
    void *pStartAcquisition{nullptr};

    /**
     * Call back for acquisition finished
     * callback argument is
     * total frames caught
     */
    void (*acquisitionFinishedCallBack)(uint64_t, void *) = nullptr;
    void *pAcquisitionFinished{nullptr};

    /**
     * Call back for raw data
     * args to raw data ready callback are
     * sls_receiver_header frame metadata
     * dataPointer is the pointer to the data
     * dataSize in bytes is the size of the data in bytes.
     */
    void (*rawDataReadyCallBack)(char *, char *, uint32_t, void *) = nullptr;

    /**
     * Call back for raw data (modified)
     * args to raw data ready callback are
     * sls_receiver_header frame metadata
     * dataPointer is the pointer to the data
     * revDatasize is the reference of data size in bytes. Can be modified to
     * the new size to be written/streamed. (only smaller value).
     */
    void (*rawDataModifyReadyCallBack)(char *, char *, uint32_t &,
                                       void *) = nullptr;

    void *pRawDataReady{nullptr};

  protected:
    std::unique_ptr<sls::ServerSocket> server{nullptr};

  private:
    void VerifyLock();
    void VerifyIdle(sls::ServerInterface2 &socket);

    slsReceiverImplementation *impl() {
        if (receiver != nullptr) {
            return receiver.get();
        } else {
            throw sls::SocketError(
                "Receiver not set up. Please use rx_hostname first.\n");
        }
    }
};