cinelerra/pluginvclient.C

   1 #include "edl.h"
   2 #include "edlsession.h"
   3 #include "pluginserver.h"
   4 #include "pluginvclient.h"
   5 #include "vframe.h"
   6
   7 #include <string.h>
   8
   9 PluginVClient::PluginVClient(PluginServer *server)
  10  : PluginClient(server)
  11 {
  12         video_in = 0;
  13         video_out = 0;
  14         temp = 0;
  15         if(server &&
  16                 server->edl &&
  17                 server->edl->session)
  18         {
  19                 project_frame_rate = server->edl->session->frame_rate;
  20                 frame_rate = project_frame_rate;
  21         }
  22         else
  23         {
  24                 project_frame_rate = 1.0;
  25                 frame_rate = project_frame_rate;
  26         }
  27 }
  28
  29 PluginVClient::~PluginVClient()
  30 {
  31         if(temp) delete temp;
  32 }
  33
  34 int PluginVClient::is_video()
  35 {
  36         return 1;
  37 }
  38
  39 VFrame* PluginVClient::new_temp(int w, int h, int color_model)
  40 {
  41         if(temp &&
  42                 (temp->get_w() != w ||
  43                 temp->get_h() != h ||
  44                 temp->get_color_model() != color_model))
  45         {
  46                 delete temp;
  47                 temp = 0;
  48         }
  49
  50         if(!temp)
  51         {
  52                 temp = new VFrame(0, w, h, color_model);
  53         }
  54
  55         return temp;
  56 }
  57
  58 void PluginVClient::age_temp()
  59 {
  60         if(temp &&
  61                 temp->get_w() > PLUGIN_MAX_W &&
  62                 temp->get_h() > PLUGIN_MAX_H)
  63         {
  64                 delete temp;
  65                 temp = 0;
  66         }
  67 }
  68
  69 // Run before every realtime buffer is to be rendered.
  70 int PluginVClient::get_render_ptrs()
  71 {
  72         int i, j, double_buffer, fragment_position;
  73
  74         for(i = 0; i < total_in_buffers; i++)
  75         {
  76                 double_buffer = double_buffer_in_render.values[i];
  77                 fragment_position = offset_in_render.values[i];
  78                 input_ptr_render[i] = &input_ptr_master.values[i][double_buffer][fragment_position];
  79         }
  80
  81         for(i = 0; i < total_out_buffers; i++)
  82         {
  83                 double_buffer = double_buffer_out_render.values[i];
  84                 fragment_position = offset_out_render.values[i];
  85                 output_ptr_render[i] = &output_ptr_master.values[i][double_buffer][fragment_position];
  86         }
  87         return 0;
  88 }
  89
  90 // Run after the non realtime plugin is run.
  91 int PluginVClient::delete_nonrealtime_parameters()
  92 {
  93         int i, j;
  94
  95         for(i = 0; i < total_in_buffers; i++)
  96         {
  97                 for(j = 0; j < in_buffer_size; j++)
  98                 {
  99                         delete video_in[i][j];
 100                 }
 101         }
 102
 103         for(i = 0; i < total_out_buffers; i++)
 104         {
 105                 for(j = 0; j < out_buffer_size; j++)
 106                 {
 107                         delete video_out[i][j];
 108                 }
 109         }
 110         video_in = 0;
 111         video_out = 0;
 112
 113         return 0;
 114 }
 115
 116 int PluginVClient::init_realtime_parameters()
 117 {
 118         project_frame_rate = server->edl->session->frame_rate;
 119         project_color_model = server->edl->session->color_model;
 120         aspect_w = server->edl->session->aspect_w;
 121         aspect_h = server->edl->session->aspect_h;
 122         return 0;
 123 }
 124
 125 int PluginVClient::process_realtime(VFrame **input,
 126         VFrame **output)
 127 {
 128         return 0;
 129 }
 130
 131 int PluginVClient::process_realtime(VFrame *input,
 132         VFrame *output)
 133 {
 134         return 0;
 135 }
 136
 137 int PluginVClient::process_buffer(VFrame **frame,
 138         int64_t start_position,
 139         double frame_rate)
 140 {
 141         for(int i = 0; i < PluginClient::total_in_buffers; i++)
 142                 read_frame(frame[i], i, start_position, frame_rate);
 143         if(is_multichannel())
 144                 process_realtime(frame, frame);
 145         return 0;
 146 }
 147
 148 int PluginVClient::process_buffer(VFrame *frame,
 149         int64_t start_position,
 150         double frame_rate)
 151 {
 152         read_frame(frame, 0, start_position, frame_rate);
 153         process_realtime(frame, frame);
 154         return 0;
 155 }
 156
 157
 158 // Replaced by pull method
 159 // void PluginVClient::plugin_process_realtime(VFrame **input,
 160 //              VFrame **output,
 161 //              int64_t current_position,
 162 //              int64_t total_len)
 163 // {
 164 //      this->source_position = current_position;
 165 //      this->total_len = total_len;
 166 //
 167 //      if(is_multichannel())
 168 //              process_realtime(input, output);
 169 //      else
 170 //              process_realtime(input[0], output[0]);
 171 // }
 172
 173 void PluginVClient::plugin_render_gui(void *data)
 174 {
 175         render_gui(data);
 176 }
 177
 178 void PluginVClient::send_render_gui(void *data)
 179 {
 180         server->send_render_gui(data);
 181 }
 182
 183 int PluginVClient::plugin_start_loop(int64_t start,
 184         int64_t end,
 185         int64_t buffer_size,
 186         int total_buffers)
 187 {
 188         frame_rate = get_project_framerate();
 189         return PluginClient::plugin_start_loop(start,
 190                 end,
 191                 buffer_size,
 192                 total_buffers);
 193 }
 194
 195 int PluginVClient::plugin_get_parameters()
 196 {
 197         frame_rate = get_project_framerate();
 198         return PluginClient::plugin_get_parameters();
 199 }
 200
 201 int64_t PluginVClient::local_to_edl(int64_t position)
 202 {
 203         if(position < 0) return position;
 204         return (int64_t)Units::round(position *
 205                 get_project_framerate() /
 206                 frame_rate);
 207         return 0;
 208 }
 209
 210 int64_t PluginVClient::edl_to_local(int64_t position)
 211 {
 212         if(position < 0) return position;
 213         return (int64_t)Units::round(position *
 214                 frame_rate /
 215                 get_project_framerate());
 216 }
 217
 218 int PluginVClient::plugin_process_loop(VFrame **buffers, int64_t &write_length)
 219 {
 220         int result = 0;
 221
 222         if(is_multichannel())
 223                 result = process_loop(buffers);
 224         else
 225                 result = process_loop(buffers[0]);
 226
 227
 228         write_length = 1;
 229
 230         return result;
 231 }
 232
 233 int PluginVClient::handle_opengl()
 234 {
 235         return 0;
 236 }
 237
 238
 239
 240
 241
 242
 243
 244 int PluginVClient::read_frame(VFrame *buffer,
 245         int channel,
 246         int64_t start_position)
 247 {
 248         return server->read_frame(buffer,
 249                 channel,
 250                 start_position);
 251 }
 252
 253 int PluginVClient::read_frame(VFrame *buffer,
 254         int64_t start_position)
 255 {
 256         return server->read_frame(buffer,
 257                 0,
 258                 start_position);
 259 }
 260
 261 int PluginVClient::read_frame(VFrame *buffer,
 262                 int channel,
 263                 int64_t start_position,
 264                 double frame_rate,
 265                 int use_opengl)
 266 {
 267         return server->read_frame(buffer,
 268                 channel,
 269                 start_position,
 270                 frame_rate,
 271                 use_opengl);
 272 }
 273
 274
 275 double PluginVClient::get_project_framerate()
 276 {
 277         return project_frame_rate;
 278 }
 279
 280 double PluginVClient::get_framerate()
 281 {
 282         return frame_rate;
 283 }
 284