hvirtual/plugins/720to480/720to480.C

   1 #include "720to480.h"
   2 #include "clip.h"
   3 #include "defaults.h"
   4 #include "filexml.h"
   5 #include "bcdisplayinfo.h"
   6 #include "keyframe.h"
   7 #include "mainprogress.h"
   8 #include "vframe.h"
   9
  10 #include <libintl.h>
  11 #define _(String) gettext(String)
  12 #define gettext_noop(String) String
  13 #define N_(String) gettext_noop (String)
  14
  15
  16 #include <stdint.h>
  17 #include <string.h>
  18
  19
  20 REGISTER_PLUGIN(_720to480Main)
  21
  22
  23 #define FORWARD 0
  24 #define REVERSE 1
  25
  26 _720to480Config::_720to480Config()
  27 {
  28         first_field = 0;
  29         direction = FORWARD;
  30 }
  31
  32
  33
  34
  35
  36 _720to480Window::_720to480Window(_720to480Main *client, int x, int y)
  37  : BC_Window(client->gui_string,
  38         x,
  39         y,
  40         230,
  41         150,
  42         230,
  43         150,
  44         0,
  45         0,
  46         1)
  47 {
  48         this->client = client;
  49 }
  50
  51
  52 _720to480Window::~_720to480Window()
  53 {
  54 }
  55
  56 int _720to480Window::create_objects()
  57 {
  58         int x = 10, y = 10;
  59
  60         add_tool(odd_first = new _720to480Order(client, this, 1, x, y, _("Odd field first")));
  61         y += 25;
  62         add_tool(even_first = new _720to480Order(client, this, 0, x, y, _("Even field first")));
  63
  64 //      y += 25;
  65 //      add_tool(forward = new _720to480Direction(client, this, FORWARD, x, y, _("Downsample")));
  66 //      y += 25;
  67 //      add_tool(reverse = new _720to480Direction(client, this, REVERSE, x, y, _("Upsample")));
  68 //
  69         add_subwindow(new BC_OKButton(this));
  70         add_subwindow(new BC_CancelButton(this));
  71
  72         show_window();
  73         flush();
  74         return 0;
  75 }
  76
  77 WINDOW_CLOSE_EVENT(_720to480Window)
  78
  79 int _720to480Window::set_first_field(int first_field)
  80 {
  81         odd_first->update(first_field == 1);
  82         even_first->update(first_field == 0);
  83
  84         client->config.first_field = first_field;
  85         return 0;
  86 }
  87
  88 int _720to480Window::set_direction(int direction)
  89 {
  90         forward->update(direction == FORWARD);
  91         reverse->update(direction == REVERSE);
  92
  93
  94         client->config.direction = direction;
  95         return 0;
  96 }
  97
  98
  99
 100 _720to480Order::_720to480Order(_720to480Main *client,
 101                 _720to480Window *window,
 102                 int output,
 103                 int x,
 104                 int y,
 105                 char *text)
 106  : BC_Radial(x,
 107         y,
 108         client->config.first_field == output,
 109         text)
 110 {
 111         this->client = client;
 112         this->window = window;
 113         this->output = output;
 114 }
 115
 116 int _720to480Order::handle_event()
 117 {
 118         window->set_first_field(output);
 119         return 1;
 120 }
 121
 122
 123
 124
 125
 126 _720to480Direction::_720to480Direction(_720to480Main *client,
 127                 _720to480Window *window,
 128                 int output,
 129                 int x,
 130                 int y,
 131                 char *text)
 132  : BC_Radial(x,
 133         y,
 134         client->config.direction == output,
 135         text)
 136 {
 137         this->client = client;
 138         this->window = window;
 139         this->output = output;
 140 }
 141
 142 int _720to480Direction::handle_event()
 143 {
 144         window->set_direction(output);
 145         return 1;
 146 }
 147
 148
 149
 150
 151
 152
 153
 154
 155
 156
 157
 158
 159
 160
 161
 162
 163 _720to480Main::_720to480Main(PluginServer *server)
 164  : PluginVClient(server)
 165 {
 166         temp = 0;
 167         load_defaults();
 168 }
 169
 170 _720to480Main::~_720to480Main()
 171 {
 172         save_defaults();
 173         delete defaults;
 174
 175         if(temp) delete temp;
 176 }
 177
 178 char* _720to480Main::plugin_title() { return _("720 to 480"); }
 179 int _720to480Main::is_realtime() { return 0; }
 180
 181 double _720to480Main::get_framerate()
 182 {
 183         return project_frame_rate / 2;
 184 }
 185
 186
 187
 188
 189
 190 int _720to480Main::load_defaults()
 191 {
 192         char directory[BCTEXTLEN], string[BCTEXTLEN];
 193         sprintf(directory, "%s720to480.rc", BCASTDIR);
 194
 195         defaults = new Defaults(directory);
 196         defaults->load();
 197         config.first_field = defaults->get("FIRST_FIELD", config.first_field);
 198         config.direction = defaults->get("DIRECTION", config.direction);
 199         return 0;
 200 }
 201
 202
 203 int _720to480Main::save_defaults()
 204 {
 205         defaults->update("FIRST_FIELD", config.first_field);
 206         defaults->update("DIRECTION", config.direction);
 207         defaults->save();
 208         return 0;
 209 }
 210
 211 int _720to480Main::get_parameters()
 212 {
 213         BC_DisplayInfo info;
 214         _720to480Window window(this,
 215                 info.get_abs_cursor_x(),
 216                 info.get_abs_cursor_y());
 217         window.create_objects();
 218         int result = window.run_window();
 219         return result;
 220 }
 221
 222 int _720to480Main::start_loop()
 223 {
 224         if(PluginClient::interactive)
 225         {
 226                 char string[BCTEXTLEN];
 227                 sprintf(string, "%s...", plugin_title());
 228                 progress = start_progress(string,
 229                         PluginClient::end - PluginClient::start);
 230         }
 231
 232         input_position = PluginClient::start;
 233         return 0;
 234 }
 235
 236
 237 int _720to480Main::stop_loop()
 238 {
 239         if(PluginClient::interactive)
 240         {
 241                 progress->stop_progress();
 242                 delete progress;
 243         }
 244         return 0;
 245 }
 246
 247
 248 #define DST_W 854
 249 #define DST_H 240
 250
 251
 252 void _720to480Main::reduce_field(VFrame *output, VFrame *input, int dest_row)
 253 {
 254         int in_w = input->get_w();
 255         int in_h = input->get_h();
 256         int out_w = output->get_w();
 257         int out_h = output->get_h();
 258
 259 #define REDUCE_MACRO(type, components) \
 260 for(int i = 0; i < DST_H; i++) \
 261 { \
 262         int output_number = dest_row + i * 2; \
 263         if(output_number >= out_h) break; \
 264  \
 265         int in1 = i * 3 + dest_row * 2; \
 266         int in2 = i * 3 + 1 + dest_row * 2; \
 267         int in3 = i * 3 + 2 + dest_row * 2; \
 268  \
 269         if(in1 >= in_h) in1 = in_h - 1; \
 270         if(in2 >= in_h) in2 = in_h - 1; \
 271         if(in3 >= in_h) in3 = in_h - 1; \
 272  \
 273         type *out_row = (type*)output->get_rows()[output_number]; \
 274         type *in_row1 = (type*)input->get_rows()[in1]; \
 275         type *in_row2 = (type*)input->get_rows()[in2]; \
 276         type *in_row3 = (type*)input->get_rows()[in3]; \
 277  \
 278         int w = MIN(out_w, in_w) * components; \
 279         for(int j = 0; j < w; j++) \
 280         { \
 281                 *out_row++ = ((int64_t)*in_row1++ + (int64_t)*in_row2++ + (int64_t)*in_row3++) / 3; \
 282         } \
 283 }
 284
 285         switch(input->get_color_model())
 286         {
 287                 case BC_RGB888:
 288                 case BC_YUV888:
 289                         REDUCE_MACRO(unsigned char, 3);
 290                         break;
 291                 case BC_RGBA8888:
 292                 case BC_YUVA8888:
 293                         REDUCE_MACRO(unsigned char, 4);
 294                         break;
 295                 case BC_RGB161616:
 296                 case BC_YUV161616:
 297                         REDUCE_MACRO(uint16_t, 3);
 298                         break;
 299                 case BC_RGBA16161616:
 300                 case BC_YUVA16161616:
 301                         REDUCE_MACRO(uint16_t, 4);
 302                         break;
 303         }
 304 }
 305
 306 int _720to480Main::process_loop(VFrame *output)
 307 {
 308         int result = 0;
 309
 310         if(!temp)
 311                 temp = new VFrame(0,
 312                         output->get_w(),
 313                         output->get_h(),
 314                         output->get_color_model());
 315
 316         if(config.direction == FORWARD)
 317         {
 318 // Step 1: Reduce vertically and put in desired fields of output
 319                 read_frame(temp, input_position);
 320                 reduce_field(output, temp, config.first_field == 0 ? 0 : 1);
 321                 input_position++;
 322
 323                 read_frame(temp, input_position);
 324                 reduce_field(output, temp, config.first_field == 0 ? 1 : 0);
 325                 input_position++;
 326         }
 327
 328         if(PluginClient::interactive)
 329                 result = progress->update(input_position - PluginClient::start);
 330
 331         if(input_position >= PluginClient::end) result = 1;
 332
 333         return result;
 334 }
 335
 336
 337
 338
 339
 340
 341 void _720to480Main::save_data(KeyFrame *keyframe)
 342 {
 343         FileXML output;
 344         output.set_shared_string(keyframe->data, MESSAGESIZE);
 345         output.tag.set_title("720TO480");
 346         output.tag.set_property("FIRST_FIELD", config.first_field);
 347         output.tag.set_property("DIRECTION", config.direction);
 348         output.append_tag();
 349         output.terminate_string();
 350 }
 351
 352 void _720to480Main::read_data(KeyFrame *keyframe)
 353 {
 354         FileXML input;
 355         input.set_shared_string(keyframe->data, strlen(keyframe->data));
 356
 357         while(!input.read_tag())
 358         {
 359                 if(input.tag.title_is("720TO480"))
 360                 {
 361                         config.first_field = input.tag.get_property("FIRST_FIELD", config.first_field);
 362                         config.direction = input.tag.get_property("DIRECTION", config.direction);
 363                 }
 364         }
 365 }
 366