cinelerra-5.1/cinelerra/vattachmentpoint.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 "bcsignals.h"
  23 #include "clip.h"
  24 #include "datatype.h"
  25 #include "edl.h"
  26 #include "edlsession.h"
  27 #include "plugin.h"
  28 #include "pluginserver.h"
  29 #include "renderengine.h"
  30 #include "transportque.h"
  31 #include "vattachmentpoint.h"
  32 #include "vdevicex11.h"
  33 #include "videodevice.h"
  34 #include "vframe.h"
  35
  36 VAttachmentPoint::VAttachmentPoint(RenderEngine *renderengine, Plugin *plugin)
  37 : AttachmentPoint(renderengine, plugin, TRACK_VIDEO)
  38 {
  39         buffer_vector = 0;
  40 }
  41
  42 VAttachmentPoint::~VAttachmentPoint()
  43 {
  44         delete_buffer_vector();
  45 }
  46
  47 void VAttachmentPoint::delete_buffer_vector()
  48 {
  49         void *This = this;
  50         if(!This) printf("VAttachmentPoint::delete_buffer_vector NULL\n");
  51         if(buffer_vector)
  52         {
  53                 for(int i = 0; i < virtual_plugins.total; i++)
  54                         delete buffer_vector[i];
  55                 delete [] buffer_vector;
  56         }
  57         buffer_vector = 0;
  58 }
  59
  60 void VAttachmentPoint::new_buffer_vector(int width, int height, int colormodel)
  61 {
  62         void *This = this;
  63         if(!This) printf("VAttachmentPoint::new_buffer_vector NULL\n");
  64         if(buffer_vector &&
  65                 (width != buffer_vector[0]->get_w() ||
  66                 height != buffer_vector[0]->get_h() ||
  67                 colormodel != buffer_vector[0]->get_color_model()))
  68         {
  69                 delete_buffer_vector();
  70         }
  71
  72         if(!buffer_vector)
  73         {
  74                 buffer_vector = new VFrame*[virtual_plugins.total];
  75                 for(int i = 0; i < virtual_plugins.total; i++)
  76                 {
  77                         buffer_vector[i] = new VFrame(0,
  78                                 -1,
  79                                 width,
  80                                 height,
  81                                 colormodel,
  82                                 -1);
  83                 }
  84         }
  85 }
  86
  87 int VAttachmentPoint::get_buffer_size()
  88 {
  89         return 1;
  90 }
  91
  92 void VAttachmentPoint::render(VFrame *output,
  93         int buffer_number,
  94         int64_t start_position,
  95         double frame_rate,
  96         int debug_render,
  97         int use_opengl)
  98 {
  99         void *This = this;
 100         if(!This) printf("VAttachmentPoint::render NULL\n");
 101         if(!plugin_server || !plugin->on) return;
 102
 103         if(debug_render)
 104                 printf("    VAttachmentPoint::render \"%s\" multi=%d opengl=%d\n",
 105                         plugin_server->title,
 106                         plugin_server->multichannel,
 107                         use_opengl);
 108
 109         if(plugin_server->multichannel)
 110         {
 111 // Test against previous parameters for reuse of previous data
 112                 if( !is_processed || this->start_position != start_position ||
 113                     !EQUIV(this->frame_rate, frame_rate)) {
 114                         is_processed = 1;
 115                         this->start_position = start_position;
 116                         this->frame_rate = frame_rate;
 117
 118 // Allocate buffer vector for subsequent render calls
 119                         new_buffer_vector(output->get_w(), output->get_h(),
 120                                 output->get_color_model());
 121 // Process plugin
 122 //printf("VAttachmentPoint::render 1 %d\n", buffer_number);
 123                         if(renderengine)
 124                                 plugin_servers.values[0]->set_use_opengl(use_opengl,
 125                                         renderengine->video);
 126                         plugin_servers.values[0]->process_buffer(buffer_vector,
 127                                 start_position, frame_rate,
 128                                 (int64_t)Units::round(plugin->length * frame_rate /
 129                                         renderengine->get_edl()->session->frame_rate),
 130                                 renderengine->command->get_direction());
 131                 }
 132 //printf("VAttachmentPoint::render 3\n");
 133 // Need to copy PBuffer if OpenGL, regardless of use_opengl
 134                 if( buffer_vector[buffer_number]->get_opengl_state() == VFrame::RAM ) {
 135                         output->copy_from(buffer_vector[buffer_number]);
 136                         output->set_opengl_state(VFrame::RAM);
 137                 }
 138                 else if(renderengine && renderengine->video) {
 139 // Need to copy PBuffer to texture
 140 // printf("VAttachmentPoint::render temp=%p output=%p\n",
 141 // buffer_vector[buffer_number],
 142 // output);
 143                         VDeviceX11 *x11_device = (VDeviceX11*)renderengine->video->get_output_base();
 144                         x11_device->copy_frame(output, buffer_vector[buffer_number]);
 145                 }
 146         }
 147         else
 148 // process single track
 149         {
 150                 VFrame *output_temp[1];
 151                 output_temp[0] = output;
 152                 if(renderengine)
 153                         plugin_servers.values[buffer_number]->set_use_opengl(use_opengl,
 154                                 renderengine->video);
 155                 plugin_servers.values[buffer_number]->process_buffer(output_temp,
 156                         start_position,
 157                         frame_rate,
 158                         (int64_t)Units::round(plugin->length *
 159                                 frame_rate /
 160                                 renderengine->get_edl()->session->frame_rate),
 161                         renderengine->command->get_direction());
 162         }
 163 }
 164
 165