cinelerra-5.0/cinelerra/pluginvclient.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "edl.h"
  23 #include "edlsession.h"
  24 #include "pluginserver.h"
  25 #include "pluginvclient.h"
  26 #include "vframe.h"
  27
  28 #include <string.h>
  29
  30 PluginVClient::PluginVClient(PluginServer *server)
  31  : PluginClient(server)
  32 {
  33         video_in = 0;
  34         video_out = 0;
  35         temp = 0;
  36         if(server &&
  37                 server->edl &&
  38                 server->edl->session)
  39         {
  40                 project_frame_rate = server->edl->session->frame_rate;
  41                 frame_rate = project_frame_rate;
  42         }
  43         else
  44         {
  45                 project_frame_rate = 1.0;
  46                 frame_rate = project_frame_rate;
  47         }
  48 }
  49
  50 PluginVClient::~PluginVClient()
  51 {
  52         if(temp) delete temp;
  53 }
  54
  55 int PluginVClient::is_video()
  56 {
  57         return 1;
  58 }
  59
  60 VFrame* PluginVClient::new_temp(int w, int h, int color_model)
  61 {
  62         if(temp &&
  63                 (temp->get_w() != w ||
  64                 temp->get_h() != h ||
  65                 temp->get_color_model() != color_model))
  66         {
  67                 delete temp;
  68                 temp = 0;
  69         }
  70
  71         if(!temp)
  72         {
  73                 temp = new VFrame(0, -1, w, h, color_model, -1);
  74         }
  75
  76         return temp;
  77 }
  78
  79 void PluginVClient::age_temp()
  80 {
  81         if(temp &&
  82                 temp->get_w() > PLUGIN_MAX_W &&
  83                 temp->get_h() > PLUGIN_MAX_H)
  84         {
  85                 delete temp;
  86                 temp = 0;
  87         }
  88 }
  89
  90 VFrame* PluginVClient::get_temp()
  91 {
  92         return temp;
  93 }
  94
  95 // Run before every realtime buffer is to be rendered.
  96 int PluginVClient::get_render_ptrs()
  97 {
  98         int i, double_buffer, fragment_position;
  99
 100         for(i = 0; i < total_in_buffers; i++)
 101         {
 102                 double_buffer = double_buffer_in_render.values[i];
 103                 fragment_position = offset_in_render.values[i];
 104                 input_ptr_render[i] = &input_ptr_master.values[i][double_buffer][fragment_position];
 105         }
 106
 107         for(i = 0; i < total_out_buffers; i++)
 108         {
 109                 double_buffer = double_buffer_out_render.values[i];
 110                 fragment_position = offset_out_render.values[i];
 111                 output_ptr_render[i] = &output_ptr_master.values[i][double_buffer][fragment_position];
 112         }
 113         return 0;
 114 }
 115
 116 // Run after the non realtime plugin is run.
 117 int PluginVClient::delete_nonrealtime_parameters()
 118 {
 119         int i, j;
 120
 121         for(i = 0; i < total_in_buffers; i++)
 122         {
 123                 for(j = 0; j < in_buffer_size; j++)
 124                 {
 125                         delete video_in[i][j];
 126                 }
 127         }
 128
 129         for(i = 0; i < total_out_buffers; i++)
 130         {
 131                 for(j = 0; j < out_buffer_size; j++)
 132                 {
 133                         delete video_out[i][j];
 134                 }
 135         }
 136         video_in = 0;
 137         video_out = 0;
 138
 139         return 0;
 140 }
 141
 142 int PluginVClient::init_realtime_parameters()
 143 {
 144         project_frame_rate = server->edl->session->frame_rate;
 145         project_color_model = server->edl->session->color_model;
 146         aspect_w = server->edl->session->aspect_w;
 147         aspect_h = server->edl->session->aspect_h;
 148         return 0;
 149 }
 150
 151 int PluginVClient::process_realtime(VFrame **input,
 152         VFrame **output)
 153 {
 154         return 0;
 155 }
 156
 157 int PluginVClient::process_realtime(VFrame *input,
 158         VFrame *output)
 159 {
 160         return 0;
 161 }
 162
 163 int PluginVClient::process_buffer(VFrame **frame,
 164         int64_t start_position,
 165         double frame_rate)
 166 {
 167         for(int i = 0; i < PluginClient::total_in_buffers; i++)
 168                 read_frame(frame[i], i, start_position, frame_rate);
 169         if(is_multichannel())
 170                 process_realtime(frame, frame);
 171         return 0;
 172 }
 173
 174 int PluginVClient::process_buffer(VFrame *frame,
 175         int64_t start_position,
 176         double frame_rate)
 177 {
 178         read_frame(frame, 0, start_position, frame_rate);
 179         process_realtime(frame, frame);
 180         return 0;
 181 }
 182
 183
 184 // Replaced by pull method
 185 // void PluginVClient::plugin_process_realtime(VFrame **input,
 186 //              VFrame **output,
 187 //              int64_t current_position,
 188 //              int64_t total_len)
 189 // {
 190 //      this->source_position = current_position;
 191 //      this->total_len = total_len;
 192 //
 193 //      if(is_multichannel())
 194 //              process_realtime(input, output);
 195 //      else
 196 //              process_realtime(input[0], output[0]);
 197 // }
 198
 199 int PluginVClient::plugin_start_loop(int64_t start,
 200         int64_t end,
 201         int64_t buffer_size,
 202         int total_buffers)
 203 {
 204         frame_rate = get_project_framerate();
 205         return PluginClient::plugin_start_loop(start,
 206                 end,
 207                 buffer_size,
 208                 total_buffers);
 209 }
 210
 211 int PluginVClient::plugin_get_parameters()
 212 {
 213         frame_rate = get_project_framerate();
 214         return PluginClient::plugin_get_parameters();
 215 }
 216
 217 int64_t PluginVClient::local_to_edl(int64_t position)
 218 {
 219         if(position < 0) return position;
 220         return (int64_t)Units::round(position *
 221                 get_project_framerate() /
 222                 frame_rate);
 223         return 0;
 224 }
 225
 226 int64_t PluginVClient::edl_to_local(int64_t position)
 227 {
 228         if(position < 0) return position;
 229         return (int64_t)Units::round(position *
 230                 frame_rate /
 231                 get_project_framerate());
 232 }
 233
 234 int PluginVClient::plugin_process_loop(VFrame **buffers, int64_t &write_length)
 235 {
 236         int result = 0;
 237
 238         if(is_multichannel())
 239                 result = process_loop(buffers);
 240         else
 241                 result = process_loop(buffers[0]);
 242
 243
 244         write_length = 1;
 245
 246         return result;
 247 }
 248
 249
 250 int PluginVClient::run_opengl()
 251 {
 252         server->run_opengl(this);
 253         return 0;
 254 }
 255
 256 int PluginVClient::handle_opengl()
 257 {
 258         return 0;
 259 }
 260
 261 VFrame* PluginVClient::get_input(int channel)
 262 {
 263         return input[channel];
 264 }
 265
 266 VFrame* PluginVClient::get_output(int channel)
 267 {
 268         return output[channel];
 269 }
 270
 271 int PluginVClient::next_effect_is(const char *title)
 272 {
 273         return !strcmp(title, output[0]->get_next_effect());
 274 }
 275
 276 int PluginVClient::prev_effect_is(const char *title)
 277 {
 278         return !strcmp(title, output[0]->get_prev_effect());
 279 }
 280
 281
 282
 283 int PluginVClient::read_frame(VFrame *buffer,
 284         int channel,
 285         int64_t start_position)
 286 {
 287         return server->read_frame(buffer,
 288                 channel,
 289                 start_position);
 290 }
 291
 292 int PluginVClient::read_frame(VFrame *buffer,
 293         int64_t start_position)
 294 {
 295         return server->read_frame(buffer,
 296                 0,
 297                 start_position);
 298 }
 299
 300 int PluginVClient::read_frame(VFrame *buffer,
 301                 int channel,
 302                 int64_t start_position,
 303                 double frame_rate,
 304                 int use_opengl)
 305 {
 306         return server->read_frame(buffer,
 307                 channel,
 308                 start_position,
 309                 frame_rate,
 310                 use_opengl);
 311 }
 312
 313
 314 double PluginVClient::get_project_framerate()
 315 {
 316         return project_frame_rate;
 317 }
 318
 319 double PluginVClient::get_framerate()
 320 {
 321         return frame_rate;
 322 }
 323