cinelerra/render.h

   1 #ifndef RENDER_H
   2 #define RENDER_H
   3
   4
   5 #include "asset.inc"
   6 #include "batchrender.inc"
   7 #include "bitspopup.h"
   8 #include "browsebutton.h"
   9 #include "cache.inc"
  10 #include "compresspopup.h"
  11 #include "condition.inc"
  12 #include "bchash.inc"
  13 #include "edit.inc"
  14 #include "errorbox.inc"
  15 #include "file.inc"
  16 #include "formatpopup.inc"
  17 #include "formattools.inc"
  18 #include "guicast.h"
  19 #include "loadmode.inc"
  20 #include "mainprogress.inc"
  21 #include "maxchannels.h"
  22 #include "mutex.inc"
  23 #include "mwindow.inc"
  24 #include "packagedispatcher.inc"
  25 #include "packagerenderer.h"
  26 #include "playabletracks.inc"
  27 #include "preferences.inc"
  28 #include "bcprogressbox.inc"
  29 #include "render.inc"
  30 #include "track.inc"
  31 #include "transportque.inc"
  32 #include "vframe.inc"
  33 #include "renderprofiles.inc"
  34
  35
  36 class RenderItem : public BC_MenuItem
  37 {
  38 public:
  39         RenderItem(MWindow *mwindow);
  40         int handle_event();
  41         MWindow *mwindow;
  42 };
  43
  44 class RenderProgress : public Thread
  45 {
  46 public:
  47         RenderProgress(MWindow *mwindow, Render *render);
  48         ~RenderProgress();
  49
  50         void run();
  51
  52
  53         MWindow *mwindow;
  54         Render *render;
  55
  56         int64_t last_value;
  57 };
  58
  59
  60
  61 class MainPackageRenderer : public PackageRenderer
  62 {
  63 public:
  64         MainPackageRenderer(Render *render);
  65         ~MainPackageRenderer();
  66
  67
  68         int get_master();
  69         int get_result();
  70         void set_result(int value);
  71         void set_progress(int64_t value);
  72         int progress_cancelled();
  73
  74         Render *render;
  75 };
  76
  77 class RenderWindow;
  78
  79
  80 class Render : public Thread
  81 {
  82 public:
  83         Render(MWindow *mwindow);
  84         ~Render();
  85
  86 // Start dialogue box and render interactively.
  87         void start_interactive();
  88 // Start batch rendering jobs.
  89 // A new thread is created and the rendering is interactive.
  90         void start_batches(ArrayList<BatchRenderJob*> *jobs);
  91 // The batches are processed in the foreground in non interactive mode.
  92         void start_batches(ArrayList<BatchRenderJob*> *jobs,
  93                 BC_Hash *boot_defaults,
  94                 Preferences *preferences,
  95                 ArrayList<PluginServer*> *plugindb);
  96 // Called by BatchRender to stop the operation.
  97         void stop_operation();
  98         void run();
  99
 100
 101 // Render single job.  Used by run.
 102         int render(int test_overwrite,
 103                 Asset *asset,
 104                 EDL *edl,
 105                 int strategy,
 106                 int range_type);
 107
 108         int load_defaults(Asset *asset);
 109         int save_defaults(Asset *asset);
 110         int load_profile(int profile_slot, Asset *asset);
 111 // force asset parameters regardless of window
 112 // This should be integrated into the Asset Class.
 113         static int check_asset(EDL *edl, Asset &asset);
 114 // Fix strategy to conform with using renderfarm.
 115         static int fix_strategy(int strategy, int use_renderfarm);
 116 // Force filename to have a 0 padded number if rendering to a list.
 117         int check_numbering(Asset &asset);
 118         static void create_filename(char *path,
 119                 char *default_path,
 120                 int current_number,
 121                 int total_digits,
 122                 int number_start);
 123         static void get_starting_number(char *path,
 124                 int &current_number,
 125                 int &number_start,
 126                 int &total_digits,
 127                 int min_digits = 3);
 128         int direct_frame_copy(EDL *edl, int64_t &render_video_position, File *file);
 129         int direct_copy_possible(EDL *edl,
 130                         int64_t current_position,
 131                         Track* playable_track,  // The one track which is playable
 132                         Edit* &playable_edit, // The edit which is playing
 133                         File *file);   // Output file
 134
 135         void start_progress();
 136         void stop_progress();
 137
 138 // Procedure the run function should use.
 139         int mode;
 140         enum
 141         {
 142                 INTERACTIVE,
 143                 BATCH
 144         };
 145 // When batch rendering is cancelled from the batch dialog
 146         int batch_cancelled;
 147
 148
 149         int load_mode;
 150         int in_progress;
 151 // Background compression must be disabled when direct frame copying and reenabled afterwards
 152         int direct_frame_copying;
 153
 154         CICache *audio_cache, *video_cache;
 155         VFrame *compressed_output;
 156         MainProgressBar *progress;
 157         RenderProgress *render_progress;
 158         MWindow *mwindow;
 159         PlayableTracks *playable_tracks;
 160         PackageDispatcher *packages;
 161         Mutex *package_lock, *counter_lock;
 162 // Copy of mwindow preferences
 163         Preferences *preferences;
 164 // For use in non interactive mode
 165         ArrayList<PluginServer*> *plugindb;
 166         int strategy;
 167         int range_type;
 168 // Total selection to render in seconds
 169         double total_start, total_end;
 170 // External Render farm checks this every frame.
 171         int result;
 172         Asset *default_asset;
 173         TransportCommand *command;
 174 // Jobs pointer passed to start_batches
 175         ArrayList<BatchRenderJob*> *jobs;
 176 // Used by batch rendering to wait until rendering is finished
 177         Condition *completion;
 178
 179
 180 // Total samples updated by the render farm and the local renderer.
 181 // This avoids rounding errors and complies with the use of samples for
 182 // timing.
 183         int64_t total_rendered;
 184 // Speed for the master node
 185         double frames_per_second;
 186 // Time used in last render
 187         double elapsed_time;
 188
 189 // Current open RenderWindow
 190         RenderWindow *render_window;
 191
 192 // For non interactive mode, maintain progress here.
 193         int64_t progress_max;
 194         Timer *progress_timer;
 195         int64_t last_eta;
 196 };
 197
 198 class RenderToTracks;
 199
 200
 201 class RenderRangeProject : public BC_Radial
 202 {
 203 public:
 204         RenderRangeProject(RenderWindow *rwindow, int value, int x, int y);
 205         int handle_event();
 206         RenderWindow *rwindow;
 207 };
 208
 209 class RenderRangeSelection : public BC_Radial
 210 {
 211 public:
 212         RenderRangeSelection(RenderWindow *rwindow, int value, int x, int y);
 213         int handle_event();
 214         RenderWindow *rwindow;
 215 };
 216
 217
 218 class RenderRangeInOut : public BC_Radial
 219 {
 220 public:
 221         RenderRangeInOut(RenderWindow *rwindow, int value, int x, int y);
 222         int handle_event();
 223         RenderWindow *rwindow;
 224 };
 225
 226
 227
 228 class RenderWindow : public BC_Window
 229 {
 230 public:
 231         RenderWindow(MWindow *mwindow, Render *render, Asset *asset);
 232         ~RenderWindow();
 233
 234         int create_objects();
 235         void update_range_type(int range_type);
 236         int load_profile(int profile_slot);
 237
 238         RenderRangeProject *rangeproject;
 239         RenderRangeSelection *rangeselection;
 240         RenderRangeInOut *rangeinout;
 241
 242         RenderProfile *renderprofile;
 243
 244         LoadMode *loadmode;
 245         FormatTools *format_tools;
 246
 247         MWindow *mwindow;
 248         Render *render;
 249         Asset *asset;
 250 };
 251
 252
 253
 254
 255
 256
 257
 258
 259
 260
 261
 262
 263
 264 #endif