cinelerra-5.1/plugins/svg/svg.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 #include "clip.h"
  22 #include "filexml.h"
  23 #include "language.h"
  24 #include "svg.h"
  25 #include "svgwin.h"
  26 #include "overlayframe.inc"
  27
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <unistd.h>
  31 #include <fcntl.h>
  32 #include <string.h>
  33 #include <errno.h>
  34 #include <sys/mman.h>
  35
  36
  37 REGISTER_PLUGIN(SvgMain)
  38
  39 SvgConfig::SvgConfig()
  40 {
  41         out_x = 0;   out_y = 0;
  42         out_w = 640; out_h = 480;
  43         dpi = 90;
  44         strcpy(svg_file, "");
  45         ms_time = 0;
  46 }
  47
  48 int SvgConfig::equivalent(SvgConfig &that)
  49 {
  50         return EQUIV(dpi, that.dpi) &&
  51                 EQUIV(out_x, that.out_x) &&
  52                 EQUIV(out_y, that.out_y) &&
  53                 EQUIV(out_w, that.out_w) &&
  54                 EQUIV(out_h, that.out_h) &&
  55                 !strcmp(svg_file, that.svg_file) &&
  56                 ms_time == that.ms_time;
  57 }
  58
  59 void SvgConfig::copy_from(SvgConfig &that)
  60 {
  61         out_x = that.out_x;
  62         out_y = that.out_y;
  63         out_w = that.out_w;
  64         out_h = that.out_h;
  65         dpi = that.dpi;
  66         strcpy(svg_file, that.svg_file);
  67         ms_time = that.ms_time;
  68 }
  69
  70 void SvgConfig::interpolate(SvgConfig &prev, SvgConfig &next,
  71         long prev_frame, long next_frame, long current_frame)
  72 {
  73         double next_scale = (double)(current_frame - prev_frame) / (next_frame - prev_frame);
  74         double prev_scale = (double)(next_frame - current_frame) / (next_frame - prev_frame);
  75
  76         this->out_x = prev.out_x * prev_scale + next.out_x * next_scale;
  77         this->out_y = prev.out_y * prev_scale + next.out_y * next_scale;
  78         this->out_w = prev.out_w * prev_scale + next.out_w * next_scale;
  79         this->out_h = prev.out_h * prev_scale + next.out_h * next_scale;
  80         this->dpi = prev.dpi;
  81         strcpy(this->svg_file, prev.svg_file);
  82         this->ms_time = prev.ms_time;
  83 }
  84
  85
  86 SvgMain::SvgMain(PluginServer *server)
  87  : PluginVClient(server)
  88 {
  89         ofrm = 0;
  90         overlayer = 0;
  91         need_reconfigure = 1;
  92 }
  93
  94 SvgMain::~SvgMain()
  95 {
  96         delete ofrm;
  97         delete overlayer;
  98 }
  99
 100 const char* SvgMain::plugin_title() { return _("SVG via Inkscape"); }
 101 int SvgMain::is_realtime() { return 1; }
 102 int SvgMain::is_synthesis() { return 1; }
 103
 104
 105 LOAD_CONFIGURATION_MACRO(SvgMain, SvgConfig)
 106
 107 void SvgMain::save_data(KeyFrame *keyframe)
 108 {
 109         FileXML output;
 110
 111 // cause data to be stored directly in text
 112         output.set_shared_output(keyframe->get_data(), MESSAGESIZE);
 113
 114         output.tag.set_title("SVG");
 115         output.tag.set_property("OUT_X", config.out_x);
 116         output.tag.set_property("OUT_Y", config.out_y);
 117         output.tag.set_property("OUT_W", config.out_w);
 118         output.tag.set_property("OUT_H", config.out_h);
 119         output.tag.set_property("DPI", config.dpi);
 120         output.tag.set_property("SVG_FILE", config.svg_file);
 121         output.tag.set_property("MS_TIME", config.ms_time);
 122         output.append_tag();
 123         output.tag.set_title("/SVG");
 124         output.append_tag();
 125
 126         output.terminate_string();
 127 }
 128
 129 void SvgMain::read_data(KeyFrame *keyframe)
 130 {
 131         FileXML input;
 132
 133         const char *data = keyframe->get_data();
 134         input.set_shared_input((char*)data, strlen(data));
 135         int result = 0;
 136
 137         while( !(result = input.read_tag()) ) {
 138                 if(input.tag.title_is("SVG")) {
 139                         config.out_x = input.tag.get_property("OUT_X", config.out_x);
 140                         config.out_y = input.tag.get_property("OUT_Y", config.out_y);
 141                         config.out_w = input.tag.get_property("OUT_W", config.out_w);
 142                         config.out_h = input.tag.get_property("OUT_H", config.out_h);
 143                         config.dpi = input.tag.get_property("DPI", config.dpi);
 144                         input.tag.get_property("SVG_FILE", config.svg_file);
 145                         config.ms_time = input.tag.get_property("MS_TIME", config.ms_time);
 146                 }
 147         }
 148 }
 149
 150
 151 int SvgMain::process_realtime(VFrame *input, VFrame *output)
 152 {
 153         if( input != output )
 154                 output->copy_from(input);
 155
 156         int need_export = 0;
 157         float last_dpi = config.dpi;
 158         char last_svg_file[BCTEXTLEN];
 159         strcpy(last_svg_file, config.svg_file);
 160         int64_t last_ms_time = config.ms_time;
 161         load_configuration();
 162         if( last_dpi != config.dpi )
 163                 need_export = 1;
 164         if( strcmp(last_svg_file, config.svg_file) ||
 165             last_ms_time != config.ms_time )
 166                 need_reconfigure = 1;
 167
 168         if( need_reconfigure || need_export ) {
 169                 need_reconfigure = 0;
 170                 if( config.svg_file[0] == 0 ) return 0;
 171                 delete ofrm;  ofrm = 0;
 172                 char filename_png[BCTEXTLEN];
 173                 strcpy(filename_png, config.svg_file);
 174                 strncat(filename_png, ".png", sizeof(filename_png));
 175                 struct stat st_png;
 176                 int64_t ms_time = need_export || stat(filename_png, &st_png) ? 0 :
 177                         st_png.st_mtim.tv_sec*1000 + st_png.st_mtim.tv_nsec/1000000;
 178                 int fd = ms_time < config.ms_time ? -1 : open(filename_png, O_RDWR);
 179                 if( fd < 0 ) { // file does not exist, export it
 180                         char command[BCTEXTLEN];
 181                         sprintf(command,
 182                                 "inkscape --without-gui --export-background=0x000000 "
 183                                 "--export-background-opacity=0 -d %f %s --export-png=%s",
 184                                 config.dpi, config.svg_file, filename_png);
 185                         printf(_("Running command %s\n"), command);
 186                         system(command);
 187                         // in order for lockf to work it has to be open for writing
 188                         fd = open(filename_png, O_RDWR);
 189                         if( fd < 0 )
 190                                 printf(_("Export of %s to %s failed\n"), config.svg_file, filename_png);
 191                 }
 192                 if( fd >= 0 ) {
 193                         ofrm = VFramePng::vframe_png(fd);
 194                         close(fd);
 195                         if( ofrm && ofrm->get_color_model() != output->get_color_model() ) {
 196                                 VFrame *vfrm = new VFrame(ofrm->get_w(), ofrm->get_h(),
 197                                         output->get_color_model());
 198                                 vfrm->transfer_from(ofrm);
 199                                 delete ofrm;  ofrm = vfrm;
 200                         }
 201                         if( !ofrm )
 202                                 printf (_("The file %s that was generated from %s is not in PNG format."
 203                                           " Try to delete all *.png files.\n"), filename_png, config.svg_file);
 204                 }
 205         }
 206         if( ofrm ) {
 207                 if(!overlayer) overlayer = new OverlayFrame(smp + 1);
 208                 overlayer->overlay(output, ofrm,
 209                          0, 0, ofrm->get_w(), ofrm->get_h(),
 210                         config.out_x, config.out_y,
 211                         config.out_x + config.out_w,
 212                         config.out_y + config.out_h,
 213                         1, TRANSFER_NORMAL, LINEAR_LINEAR);
 214         }
 215         return 0;
 216 }
 217
 218
 219 NEW_WINDOW_MACRO(SvgMain, SvgWin)
 220
 221 void SvgMain::update_gui()
 222 {
 223         if(thread) {
 224                 load_configuration();
 225                 SvgWin *window = (SvgWin*)thread->window;
 226                 window->update_gui(config);
 227         }
 228 }
 229