---

VideoStream.h

Go to the documentation of this file.

/***************************************************************************
 *cr
 *cr            (C) Copyright 1995-2019 The Board of Trustees of the
 *cr                        University of Illinois
 *cr                         All Rights Reserved
 *cr
 ***************************************************************************/

/***************************************************************************
* RCS INFORMATION:
*
*      $RCSfile: OptiXDisplayDevice.h
*      $Author: johns $      $Locker:  $               $State: Exp $
*      $Revision: 1.22 $         $Date: 2020/10/15 16:07:31 $
*
***************************************************************************
* DESCRIPTION:
*   VMD interface for video streaming
*
***************************************************************************/

#ifndef VIDEOSTREAM_H
#define VIDEOSTREAM_H

#define VIDEOSTREAM_SUCCESS  0
#define VIDEOSTREAM_ERROR   -1

// #define VIDEOSTREAM_STATICBUFS 1

#include <stdlib.h>
#include "UIObject.h"
#include "WKFUtils.h"

struct VSMsgHeader_t;

class VideoStream : public UIObject {
  public:
    VideoStream(VMDApp *);
    ~VideoStream(void);

    int cli_listen(int port);
    int cli_connect(const char *hostname, int port);
    int cli_wait_msg();
    int cli_disconnect();
    const char *cli_gethost() { return "Unknown"; };
    int cli_getport() { return 0; };
    int cli_connected() { return (cli_socket != NULL); }
    int cli_decode_frame(unsigned char *cbuf, long cbufsz,
                         unsigned char *rgba, int width, int height);

    // client-side UI event transmission routines
    int cli_send_rotate_by(float angle, char axis);
    int cli_send_translate_by(float dx, float dy, float dz);
    int cli_send_scale_by(float scalefactor);
    int cli_send_keyboard(int dev, char val, int shift_state);

    int srv_listen(int port);
    int srv_connect(const char *hostname, int port);
    int srv_send_frame(const unsigned char *rgba, int pitch, 
                       int width, int height, int forceIFrame);
    int srv_disconnect();
    const char *srv_gethost() { return "Unknown"; };
    int srv_getport() { return 0; };
    int srv_connected() { return (srv_socket != NULL); }

    int set_target_bitrate_Mbps(float Mbps) { 
      vs_bitrateMbps = int(Mbps);
      vs_codec_reconfig_pending = 1;
      return 0;
    }

    int set_target_frame_rate(float tfps) { 
      vs_targetFPS = int(tfps); 
      vs_codec_reconfig_pending = 1;
      return 0;
    }

    // Key virtual methods inherited from UIObject
    int check_event();
    int act_on_command(int, Command *);

    // methods used to inform videostream of graphics updates 
    // and/or to funnel in incoming image data
    void video_frame_pending(const unsigned char *ptr = NULL,
                             int pwidth=0, int pheight=0) { 
      vs_rgba_pend = ptr;
      vs_rgba_width = pwidth;
      vs_rgba_height = pheight;
      vs_framepending = 1; 
    }
    void video_frame_force_Iframe() { vs_forceIframe = 1; }

    enum VSEventDev {
      VS_EV_NONE,                       
      VS_EV_ROTATE_BY,                  
      VS_EV_TRANSLATE_BY,               
      VS_EV_SCALE_BY,                   
      VS_EV_KEYBOARD                    
    };

    // special method for use by OptiXRenderer
    int srv_check_ui_event();

    int srv_process_all_events() { 
      srv_get_one_ui_event=0; 
      return 0;
    }

    int srv_get_last_event_type(int &eventtype) { 
      eventtype = srv_last_event_type; 
      return 0;
    }

    int srv_get_last_rotate_by(float &angle, int &axis) {
      angle = srv_last_rotate_by_angle;
      axis = srv_last_rotate_by_axis;

      srv_last_event_type = VS_EV_NONE; // clear event so we read it only once
      return 0;
    }

    int srv_get_last_translate_by(float &tx, float &ty, float &tz) {
      tx = srv_last_translate_by_vec[0];
      ty = srv_last_translate_by_vec[1];
      tz = srv_last_translate_by_vec[2];
 
      srv_last_event_type = VS_EV_NONE; // clear event so we read it only once
      return 0;
    }

    int srv_get_last_scale_by(float &factor) {
      factor = srv_last_scale_by_factor;

      srv_last_event_type = VS_EV_NONE; // clear event so we read it only once
      return 0;
    }

    int srv_get_last_keyboard(int &dev, int &val, int &shift_state) {
      dev = srv_last_key_dev;
      val = srv_last_key_val;
      shift_state = srv_last_key_shift_state;

      srv_last_event_type = VS_EV_NONE; // clear event so we read it only once
      return 0;
    }

  private:
    int srv_get_one_ui_event;           

    int srv_last_event_type;            
    int srv_last_rotate_by_axis;        
    float srv_last_rotate_by_angle;     
    float srv_last_translate_by_vec[3]; 
    float srv_last_scale_by_factor;     
    int srv_last_key_dev;               
    int srv_last_key_val;               
    int srv_last_key_shift_state;       

    int vs_framepending;                
    const unsigned char *vs_rgba_pend;  
    int vs_rgba_width;                  
    int vs_rgba_height;                 

    int vs_forceIframe;                 
    int vs_width;                       
    int vs_height;                      
    int vs_targetFPS;                   
    int vs_bitrateMbps;                 
    int vs_codec_reconfig_pending;      

    double imagesz_comp;                
    double imagesz_uncomp;              
    double expave_fps;                  

    void *ench;                         
    void *cli_socket;                   
    void *srv_socket;                   

#if defined(VIDEOSTREAM_STATICBUFS)
    unsigned char *vs_imgbuf;           
    int vs_imgbufsz;                    
    unsigned char *vs_cbuf;             
    int vs_cbufsz;                      
#endif

    wkf_timerhandle timer;              
    double lastconsolemesg;             
    double cli_lastmsgtime;             
    double cli_lastframe;               
    double srv_lastmsgtime;             
    double srv_lastframe;               
    int lastmsgeventloops;              

    enum VSMsgType {
        VS_HANDSHAKE,                   
        VS_GO,                          
        VS_PAUSE,                       
        VS_CODEC_RECONFIG,              
        VS_IMAGE,                       
        VS_RESIZE,                      
#if 0
        VS_KILL,                        
        VS_TRATE,                       
#endif
        VS_UIEVENT,                     
        VS_HEARTBEAT,                   
        VS_DISCONNECT,                  
        VS_IOERROR                      
    };

    int vs_encoder_reconfig();

    int vs_recv_handshake(void *sock);
    int vs_send_handshake(void *s);

    int vs_recv_header(void *s, VSMsgHeader_t &header);
    int vs_recv_header_nolengthswap(void *s, int *length);
    int vs_readn(void *s, char *ptr, int n);
    int vs_readn_discard(void *s, int n);
    int vs_writen(void *s, const char *ptr, int n);
    int vs_send_disconnect(void *s);
    int vs_send_pause(void *s);
    int vs_send_go(void *s); 
    int vs_send_heartbeat(void *s);
    int vs_send_resize(void *s, int w, int h);
    int vs_send_codec_reconfig(void *s, int bitrateMbps, int targetFPS);
};

#endif

---