cinelerra/renderfarm.h

   1 #ifndef RENDERFARM_H
   2 #define RENDERFARM_H
   3
   4
   5 #include "arraylist.h"
   6 #include "asset.inc"
   7 #include "brender.inc"
   8 #include "defaults.inc"
   9 #include "edl.inc"
  10 #include "mutex.inc"
  11 #include "mwindow.inc"
  12 #include "packagedispatcher.inc"
  13 #include "pluginserver.inc"
  14 #include "preferences.inc"
  15 #include "render.inc"
  16 #include "renderfarm.inc"
  17 #include "renderfarmclient.inc"
  18 #include "renderfarmfsserver.inc"
  19 #include "thread.h"
  20
  21 #include <stdint.h>
  22
  23 // Request format
  24 // 1 byte -> request code
  25 // 4 bytes -> size of packet exclusive
  26 // size of packet -> data
  27
  28
  29
  30 // General reply format
  31 // 4 bytes -> size of packet exclusive
  32 // size of packet -> data
  33
  34 #define STORE_INT32(value) \
  35         datagram[i++] = (((uint32_t)(value)) >> 24) & 0xff; \
  36         datagram[i++] = (((uint32_t)(value)) >> 16) & 0xff; \
  37         datagram[i++] = (((uint32_t)(value)) >> 8) & 0xff; \
  38         datagram[i++] = ((uint32_t)(value)) & 0xff;
  39
  40 #define STORE_INT64(value) \
  41         datagram[i++] = (((uint64_t)(value)) >> 56) & 0xff; \
  42         datagram[i++] = (((uint64_t)(value)) >> 48) & 0xff; \
  43         datagram[i++] = (((uint64_t)(value)) >> 40) & 0xff; \
  44         datagram[i++] = (((uint64_t)(value)) >> 32) & 0xff; \
  45         datagram[i++] = (((uint64_t)(value)) >> 24) & 0xff; \
  46         datagram[i++] = (((uint64_t)(value)) >> 16) & 0xff; \
  47         datagram[i++] = (((uint64_t)(value)) >> 8) & 0xff; \
  48         datagram[i++] = ((uint64_t)(value)) & 0xff;
  49
  50 #define READ_INT32(data) \
  51         ((((uint32_t)(data)[0]) << 24) |  \
  52         (((uint32_t)(data)[1]) << 16) |  \
  53         (((uint32_t)(data)[2]) << 8) |  \
  54         ((uint32_t)(data)[3]))
  55
  56 #define READ_INT64(data) \
  57         ((((uint64_t)(data)[0]) << 56) |  \
  58         (((uint64_t)(data)[1]) << 48) |  \
  59         (((uint64_t)(data)[2]) << 40) |  \
  60         (((uint64_t)(data)[3]) << 32) |  \
  61         (((uint64_t)(data)[4]) << 24) |  \
  62         (((uint64_t)(data)[5]) << 16) |  \
  63         (((uint64_t)(data)[6]) << 8) |  \
  64         ((uint64_t)(data)[7]))
  65
  66
  67 // Request codes to be used in both client and server.
  68 enum
  69 {
  70         RENDERFARM_PREFERENCES,  // 0 Get preferences on startup
  71         RENDERFARM_ASSET,        // Get output format on startup
  72         RENDERFARM_EDL,          // Get EDL on startup
  73         RENDERFARM_PACKAGE,      // Get one package after another to render
  74         RENDERFARM_PROGRESS,     // Update completion total
  75         RENDERFARM_SET_RESULT,   // Update error status
  76         RENDERFARM_GET_RESULT,   // Retrieve error status
  77         RENDERFARM_DONE,         // Quit
  78         RENDERFARM_SET_VMAP,     // 8 Update video map in background rendering
  79
  80 // VFS commands
  81         RENDERFARM_FOPEN,      // 9
  82         RENDERFARM_FCLOSE,
  83         RENDERFARM_REMOVE,
  84         RENDERFARM_RENAME,
  85         RENDERFARM_FGETC,
  86         RENDERFARM_FPUTC,
  87         RENDERFARM_FREAD,      // 15
  88         RENDERFARM_FWRITE,
  89         RENDERFARM_FSEEK,
  90         RENDERFARM_FTELL,
  91         RENDERFARM_STAT,
  92         RENDERFARM_STAT64,     // 20
  93         RENDERFARM_FGETS,      // 21
  94         RENDERFARM_FILENO
  95 };
  96
  97
  98 class RenderFarmServer
  99 {
 100 public:
 101 // MWindow is required to get the plugindb to save the EDL.
 102         RenderFarmServer(ArrayList<PluginServer*> *plugindb,
 103                 PackageDispatcher *packages,
 104                 Preferences *preferences,
 105                 int use_local_rate,
 106                 int *result_return,
 107                 int64_t *total_return,
 108                 Mutex *total_return_lock,
 109                 Asset *default_asset,
 110                 EDL *edl,
 111                 BRender *brender);
 112         virtual ~RenderFarmServer();
 113
 114
 115 // Open connections to clients.
 116         int start_clients();
 117 // The render farm must wait for all the clients to finish.
 118         int wait_clients();
 119
 120 // Likewise the render farm must check the internal render loop before
 121 // dispatching the next job and whenever a client queries for errors.
 122
 123
 124         ArrayList<RenderFarmServerThread*> clients;
 125         ArrayList<PluginServer*> *plugindb;
 126 //      MWindow *mwindow;
 127         PackageDispatcher *packages;
 128         Preferences *preferences;
 129 // Use master node's framerate
 130         int use_local_rate;
 131         int *result_return;
 132         int64_t *total_return;
 133         Mutex *total_return_lock;
 134         Asset *default_asset;
 135         EDL *edl;
 136         Mutex *client_lock;
 137         BRender *brender;
 138 };
 139
 140
 141 // Waits for requests from every client.
 142 // Joins when the client is finished.
 143 class RenderFarmServerThread : public Thread
 144 {
 145 public:
 146         RenderFarmServerThread(ArrayList<PluginServer*> *plugindb,
 147                 RenderFarmServer *server,
 148                 int number);
 149         ~RenderFarmServerThread();
 150
 151         static int read_socket(int socket_fd, char *data, int len, int timeout);
 152         static int write_socket(int socket_fd, char *data, int len, int timeout);
 153 // Inserts header and writes string to socket
 154         static int write_string(int socket_fd, char *string);
 155
 156
 157
 158
 159         int read_socket(char *data, int len, int timeout);
 160         int write_socket(char *data, int len, int timeout);
 161         int start_loop();
 162         void send_preferences();
 163         void send_asset();
 164         void send_edl();
 165         void send_package(unsigned char *buffer);
 166         void set_progress(unsigned char *buffer);
 167         void set_video_map(unsigned char *buffer);
 168         void set_result(unsigned char *buffer);
 169         void get_result();
 170         void reallocate_buffer(int size);
 171
 172
 173         void run();
 174
 175 //      MWindow *mwindow;
 176         ArrayList<PluginServer*> *plugindb;
 177         RenderFarmServer *server;
 178         RenderFarmFSServer *fs_server;
 179         int socket_fd;
 180         int number;
 181 // Rate of last job or 0
 182         double frames_per_second;
 183 // Pointer to default asset
 184         Asset *default_asset;
 185         unsigned char *buffer;
 186         int64_t buffer_allocated;
 187 };
 188
 189
 190
 191
 192
 193
 194 #endif