hvirtual/cinelerra/renderfarmclient.h

   1 #ifndef RENDERFARMCLIENT_H
   2 #define RENDERFARMCLIENT_H
   3
   4 #include "arraylist.h"
   5 #include "asset.inc"
   6 #include "defaults.inc"
   7 #include "edl.inc"
   8 #include "packagerenderer.h"
   9 #include "pluginserver.inc"
  10 #include "preferences.inc"
  11 #include "renderfarmclient.inc"
  12 #include "renderfarmfsclient.inc"
  13 #include "thread.h"
  14
  15 // The render client waits for connections from the server.
  16 // Then it starts a thread for each connection.
  17 class RenderFarmClient
  18 {
  19 public:
  20         RenderFarmClient(int port,
  21                 char *deamon_path,
  22                 int nice_value,
  23                 char *config_path);
  24         ~RenderFarmClient();
  25
  26         void main_loop();
  27
  28
  29 // After a socket times out, kill the render node.
  30         void kill_client();
  31
  32         RenderFarmClientThread *thread;
  33
  34         int port;
  35         char *deamon_path;
  36 // PID to be returned to background render object
  37         int this_pid;
  38 // The plugin paths must be known before any threads are started
  39         Defaults *boot_defaults;
  40         Preferences *boot_preferences;
  41         ArrayList<PluginServer*> *plugindb;
  42 };
  43
  44 // When a connection is opened, the thread forks to handle the rendering session.
  45 // A fork instead of a thread is used to avoid reentrancy problems with the
  46 // codecs, but we still need a thread to join the process.
  47 //
  48 // The fork requests jobs from the server until the job table is empty
  49 // or the server reports an error.  This fork must poll the server
  50 // after every frame for the error status.
  51 // Detaches when finished.
  52 class RenderFarmClientThread : Thread
  53 {
  54 public:
  55         RenderFarmClientThread(RenderFarmClient *client);
  56         ~RenderFarmClientThread();
  57
  58 // Commands call this to send the request packet.
  59 // The ID of the request followed by the size of the data that follows is sent.
  60         int send_request_header(int request,
  61                 int len);
  62         int write_socket(char *data, int len, int timeout);
  63         int read_socket(char *data, int len, int timeout);
  64         void read_string(int socket_fd, char* &string);
  65         void lock(char *location);
  66         void unlock();
  67
  68
  69
  70
  71
  72         void RenderFarmClientThread::read_preferences(int socket_fd,
  73                 Preferences *preferences);
  74         void read_asset(int socket_fd, Asset *asset);
  75         void read_edl(int socket_fd,
  76                 EDL *edl,
  77                 Preferences *preferences);
  78         int read_package(int socket_fd, RenderPackage *package);
  79         int send_completion(int socket_fd);
  80
  81         void main_loop(int socket_fd);
  82         void run();
  83
  84 // Everything must be contained in run()
  85         int socket_fd;
  86 // Read only
  87         RenderFarmClient *client;
  88         RenderFarmFSClient *fs_client;
  89         double frames_per_second;
  90         Mutex *mutex_lock;
  91 };
  92
  93
  94
  95
  96
  97
  98
  99
 100
 101
 102
 103
 104 class FarmPackageRenderer : public PackageRenderer
 105 {
 106 public:
 107         FarmPackageRenderer(RenderFarmClientThread *thread,
 108                 int socket_fd);
 109         ~FarmPackageRenderer();
 110
 111
 112         int get_result();
 113         void set_result(int value);
 114         void set_progress(int64_t total_samples);
 115         void set_video_map(int64_t position, int value);
 116
 117
 118         int socket_fd;
 119         RenderFarmClientThread *thread;
 120 };
 121
 122
 123
 124
 125
 126
 127
 128
 129
 130 #endif