plugins/freezeframe/freezeframe.C

   1 #include "bcdisplayinfo.h"
   2 #include "bchash.h"
   3 #include "filexml.h"
   4 #include "freezeframe.h"
   5 #include "language.h"
   6 #include "picon_png.h"
   7
   8
   9
  10 #include <string.h>
  11
  12
  13 REGISTER_PLUGIN(FreezeFrameMain)
  14
  15
  16
  17
  18
  19 FreezeFrameConfig::FreezeFrameConfig()
  20 {
  21         enabled = 0;
  22         line_double = 0;
  23 }
  24
  25 void FreezeFrameConfig::copy_from(FreezeFrameConfig &that)
  26 {
  27         enabled = that.enabled;
  28         line_double = that.line_double;
  29 }
  30
  31 int FreezeFrameConfig::equivalent(FreezeFrameConfig &that)
  32 {
  33         return enabled == that.enabled &&
  34                 line_double == that.line_double;
  35 }
  36
  37 void FreezeFrameConfig::interpolate(FreezeFrameConfig &prev,
  38         FreezeFrameConfig &next,
  39         long prev_frame,
  40         long next_frame,
  41         long current_frame)
  42 {
  43         this->enabled = prev.enabled;
  44         this->line_double = prev.line_double;
  45 }
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56 FreezeFrameWindow::FreezeFrameWindow(FreezeFrameMain *client, int x, int y)
  57  : BC_Window(client->get_gui_string(),
  58         x,
  59         y,
  60         200,
  61         100,
  62         200,
  63         100,
  64         0,
  65         0,
  66         1)
  67 {
  68         this->client = client;
  69 }
  70
  71 FreezeFrameWindow::~FreezeFrameWindow()
  72 {
  73 }
  74
  75 int FreezeFrameWindow::create_objects()
  76 {
  77         int x = 10, y = 10;
  78         add_tool(enabled = new FreezeFrameToggle(client,
  79                 &client->config.enabled,
  80                 x,
  81                 y,
  82                 _("Enabled")));
  83 // Try using extra effect for the line double since it doesn't
  84 // change the overhead.
  85 //      y += 30;
  86 //      add_tool(line_double = new FreezeFrameToggle(client,
  87 //              &client->config.line_double,
  88 //              x,
  89 //              y,
  90 //              _("Line double")));
  91         show_window();
  92         flush();
  93         return 0;
  94 }
  95
  96 WINDOW_CLOSE_EVENT(FreezeFrameWindow)
  97
  98
  99
 100
 101 PLUGIN_THREAD_OBJECT(FreezeFrameMain, FreezeFrameThread, FreezeFrameWindow)
 102
 103
 104
 105
 106
 107 FreezeFrameToggle::FreezeFrameToggle(FreezeFrameMain *client,
 108         int *value,
 109         int x,
 110         int y,
 111         char *text)
 112  : BC_CheckBox(x, y, *value, text)
 113 {
 114         this->client = client;
 115         this->value = value;
 116 }
 117 FreezeFrameToggle::~FreezeFrameToggle()
 118 {
 119 }
 120 int FreezeFrameToggle::handle_event()
 121 {
 122         *value = get_value();
 123         client->send_configure_change();
 124         return 1;
 125 }
 126
 127
 128
 129
 130
 131
 132
 133
 134
 135
 136
 137
 138 FreezeFrameMain::FreezeFrameMain(PluginServer *server)
 139  : PluginVClient(server)
 140 {
 141         PLUGIN_CONSTRUCTOR_MACRO
 142         first_frame = 0;
 143         first_frame_position = -1;
 144 }
 145
 146 FreezeFrameMain::~FreezeFrameMain()
 147 {
 148         PLUGIN_DESTRUCTOR_MACRO
 149         if(first_frame) delete first_frame;
 150 }
 151
 152 char* FreezeFrameMain::plugin_title() { return N_("Freeze Frame"); }
 153 int FreezeFrameMain::is_synthesis() { return 1; }
 154 int FreezeFrameMain::is_realtime() { return 1; }
 155
 156
 157 SHOW_GUI_MACRO(FreezeFrameMain, FreezeFrameThread)
 158
 159 RAISE_WINDOW_MACRO(FreezeFrameMain)
 160
 161 SET_STRING_MACRO(FreezeFrameMain)
 162
 163 NEW_PICON_MACRO(FreezeFrameMain)
 164
 165 int FreezeFrameMain::load_configuration()
 166 {
 167         KeyFrame *prev_keyframe = get_prev_keyframe(get_source_position());
 168         int64_t prev_position = edl_to_local(prev_keyframe->position);
 169         if(prev_position < get_source_start()) prev_position = get_source_start();
 170         read_data(prev_keyframe);
 171 // Invalidate stored frame
 172         if(config.enabled) first_frame_position = prev_position;
 173         return 0;
 174 }
 175
 176 void FreezeFrameMain::update_gui()
 177 {
 178         if(thread)
 179         {
 180                 load_configuration();
 181                 thread->window->lock_window();
 182                 thread->window->enabled->update(config.enabled);
 183 //              thread->window->line_double->update(config.line_double);
 184                 thread->window->unlock_window();
 185         }
 186 }
 187
 188 void FreezeFrameMain::save_data(KeyFrame *keyframe)
 189 {
 190         FileXML output;
 191
 192 // cause data to be stored directly in text
 193         output.set_shared_string(keyframe->data, MESSAGESIZE);
 194         output.tag.set_title("FREEZEFRAME");
 195         output.append_tag();
 196         if(config.enabled)
 197         {
 198                 output.tag.set_title("ENABLED");
 199                 output.append_tag();
 200         }
 201         if(config.line_double)
 202         {
 203                 output.tag.set_title("LINE_DOUBLE");
 204                 output.append_tag();
 205         }
 206         output.terminate_string();
 207 // data is now in *text
 208 }
 209
 210 void FreezeFrameMain::read_data(KeyFrame *keyframe)
 211 {
 212         FileXML input;
 213
 214         input.set_shared_string(keyframe->data, strlen(keyframe->data));
 215
 216         int result = 0;
 217         config.enabled = 0;
 218         config.line_double = 0;
 219
 220         while(!result)
 221         {
 222                 result = input.read_tag();
 223
 224                 if(!result)
 225                 {
 226                         if(input.tag.title_is("ENABLED"))
 227                         {
 228                                 config.enabled = 1;
 229                         }
 230                         if(input.tag.title_is("LINE_DOUBLE"))
 231                         {
 232                                 config.line_double = 1;
 233                         }
 234                 }
 235         }
 236 }
 237
 238 int FreezeFrameMain::load_defaults()
 239 {
 240         char directory[BCTEXTLEN], string[BCTEXTLEN];
 241 // set the default directory
 242         sprintf(directory, "%sfreezeframe.rc", BCASTDIR);
 243
 244 // load the defaults
 245         defaults = new BC_Hash(directory);
 246         defaults->load();
 247
 248         config.enabled = defaults->get("ENABLED", config.enabled);
 249         config.line_double = defaults->get("LINE_DOUBLE", config.line_double);
 250         return 0;
 251 }
 252
 253 int FreezeFrameMain::save_defaults()
 254 {
 255         defaults->update("ENABLED", config.enabled);
 256         defaults->update("LINE_DOUBLE", config.line_double);
 257         defaults->save();
 258         return 0;
 259 }
 260
 261
 262
 263
 264
 265
 266 int FreezeFrameMain::process_buffer(VFrame *frame,
 267                 int64_t start_position,
 268                 double frame_rate)
 269 {
 270         int64_t previous_first_frame = first_frame_position;
 271         load_configuration();
 272
 273 // Just entered frozen range
 274         if(!first_frame && config.enabled)
 275         {
 276                 if(!first_frame)
 277                         first_frame = new VFrame(0,
 278                                 frame->get_w(),
 279                                 frame->get_h(),
 280                                 frame->get_color_model());
 281                 read_frame(first_frame,
 282                                 0,
 283                                 first_frame_position,
 284                                 frame_rate);
 285                 frame->copy_from(first_frame);
 286         }
 287         else
 288 // Still not frozen
 289         if(!first_frame && !config.enabled)
 290         {
 291                 read_frame(frame,
 292                         0,
 293                         start_position,
 294                         frame_rate);
 295         }
 296         else
 297 // Just left frozen range
 298         if(first_frame && !config.enabled)
 299         {
 300                 delete first_frame;
 301                 first_frame = 0;
 302                 read_frame(frame,
 303                         0,
 304                         start_position,
 305                         frame_rate);
 306         }
 307         else
 308 // Still frozen
 309         if(first_frame && config.enabled)
 310         {
 311 // Had a keyframe in frozen range.  Load new first frame
 312                 if(previous_first_frame != first_frame_position)
 313                 {
 314                         read_frame(first_frame,
 315                                 0,
 316                                 first_frame_position,
 317                                 frame_rate);
 318                 }
 319                 frame->copy_from(first_frame);
 320         }
 321
 322
 323 // Line double to support interlacing
 324 //      if(config.line_double && config.enabled)
 325 //      {
 326 //              for(int i = 0; i < frame->get_h() - 1; i += 2)
 327 //              {
 328 //                      memcpy(frame->get_rows()[i + 1],
 329 //                              frame->get_rows()[i],
 330 //                              frame->get_bytes_per_line());
 331 //              }
 332 //      }
 333
 334
 335
 336         return 0;
 337 }
 338