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 abort();
  65         void read_string(int socket_fd, char* &string);
  66         void lock(char *location);
  67         void unlock();
  68
  69
  70
  71
  72
  73         void read_preferences(int socket_fd,
  74                 Preferences *preferences);
  75         void read_asset(int socket_fd, Asset *asset);
  76         void read_edl(int socket_fd,
  77                 EDL *edl,
  78                 Preferences *preferences);
  79         int read_package(int socket_fd, RenderPackage *package);
  80         int send_completion(int socket_fd);
  81
  82         void main_loop(int socket_fd);
  83         void run();
  84
  85 // Everything must be contained in run()
  86         int socket_fd;
  87 // Read only
  88         RenderFarmClient *client;
  89 //      RenderFarmFSClient *fs_client;
  90         double frames_per_second;
  91         Mutex *mutex_lock;
  92 };
  93
  94
  95
  96
  97
  98
  99
 100
 101
 102
 103
 104
 105 class FarmPackageRenderer : public PackageRenderer
 106 {
 107 public:
 108         FarmPackageRenderer(RenderFarmClientThread *thread,
 109                 int socket_fd);
 110         ~FarmPackageRenderer();
 111
 112
 113         int get_result();
 114         void set_result(int value);
 115         void set_progress(int64_t total_samples);
 116         int set_video_map(int64_t position, int value);
 117
 118
 119         int socket_fd;
 120         RenderFarmClientThread *thread;
 121 };
 122
 123
 124
 125
 126
 127
 128
 129
 130
 131 #endif