src/lua/inputmovie.cpp

   1 #include "lua/internal.hpp"
   2 #include "library/string.hpp"
   3 #include "library/minmax.hpp"
   4 #include "core/dispatch.hpp"
   5 #include "core/instance.hpp"
   6 #include "core/moviedata.hpp"
   7 #include "core/messages.hpp"
   8 #include "core/window.hpp"
   9 #include <fstream>
  10
  11
  12 namespace
  13 {
  14         class lua_inputmovie;
  15
  16         class lua_inputframe
  17         {
  18                 friend class lua_inputmovie;
  19         public:
  20                 lua_inputframe(lua::state& L, portctrl::frame _f);
  21                 static size_t overcommit(portctrl::frame _f) { return 0; }
  22                 int get_button(lua::state& L, lua::parameters& P)
  23                 {
  24                         unsigned port, controller, button;
  25
  26                         P(P.skipped(), port, controller, button);
  27
  28                         short value = getbutton(port, controller, button);
  29                         L.pushboolean(value ? 1 : 0);
  30                         return 1;
  31                 }
  32                 int get_axis(lua::state& L, lua::parameters& P)
  33                 {
  34                         unsigned port, controller, button;
  35
  36                         P(P.skipped(), port, controller, button);
  37
  38                         short value = getbutton(port, controller, button);
  39                         L.pushnumber(value);
  40                         return 1;
  41                 }
  42                 int set_axis(lua::state& L, lua::parameters& P)
  43                 {
  44                         unsigned port, controller, button;
  45                         short value;
  46
  47                         P(P.skipped(), port, controller, button);
  48                         if(P.is_boolean()) value = P.arg<bool>() ? 1 : 0;
  49                         else if(P.is_number()) value = P.arg<short>();
  50                         else
  51                                 P.expected("number or boolean");
  52
  53                         setbutton(port, controller, button, value);
  54                         return 0;
  55                 }
  56                 int serialize(lua::state& L, lua::parameters& P)
  57                 {
  58                         char buf[MAX_SERIALIZED_SIZE];
  59                         f.serialize(buf);
  60                         L.pushstring(buf);
  61                         return 1;
  62                 }
  63                 int unserialize(lua::state& L, lua::parameters& P)
  64                 {
  65                         std::string buf;
  66
  67                         P(P.skipped(), buf);
  68
  69                         f.deserialize(buf.c_str());
  70                         return 0;
  71                 }
  72                 int get_stride(lua::state& L, lua::parameters& P)
  73                 {
  74                         L.pushnumber(f.size());
  75                         return 1;
  76                 }
  77                 portctrl::frame& get_frame()
  78                 {
  79                         return f;
  80                 }
  81                 std::string print()
  82                 {
  83                         char buf[MAX_SERIALIZED_SIZE];
  84                         f.serialize(buf);
  85                         return buf;
  86                 }
  87         private:
  88                 short getbutton(unsigned port, unsigned controller, unsigned index)
  89                 {
  90                         return f.axis3(port, controller, index);
  91                 }
  92                 void setbutton(unsigned port, unsigned controller, unsigned index, short value)
  93                 {
  94                         return f.axis3(port, controller, index, value);
  95                 }
  96                 portctrl::frame f;
  97         };
  98
  99         int32_t get_pc_for(unsigned port, unsigned controller, unsigned button, bool extra0 = false);
 100         int32_t get_pc_for(unsigned port, unsigned controller, unsigned button, bool extra0)
 101         {
 102                 movie& m = CORE().mlogic->get_movie();
 103                 if(port == 0 && controller == 0 && button == 0)
 104                         return m.get_pollcounters().max_polls() + (extra0 ? 1 : 0);
 105                 if(port == 0 && controller == 0 && m.get_pollcounters().get_framepflag())
 106                         return max(m.get_pollcounters().get_polls(port, controller, button), (uint32_t)1);
 107                 return m.get_pollcounters().get_polls(port, controller, button);
 108         }
 109
 110         void check_can_edit(unsigned port, unsigned controller, unsigned button, uint64_t frame,
 111                 bool allow_past_end = false);
 112
 113         void check_can_edit(unsigned port, unsigned controller, unsigned button, uint64_t frame,
 114                 bool allow_past_end)
 115         {
 116                 auto& core = CORE();
 117                 movie& m = core.mlogic->get_movie();
 118                 if(!m.readonly_mode())
 119                         throw std::runtime_error("Not in playback mode");
 120                 if(!allow_past_end && frame >= core.mlogic->get_mfile().input->size())
 121                         throw std::runtime_error("Index out of movie");
 122                 int32_t pc = get_pc_for(port, controller, button, true);
 123                 if(pc < 0)
 124                         throw std::runtime_error("Invalid control to edit");
 125                 uint64_t firstframe = m.get_current_frame_first_subframe();
 126                 uint64_t minframe = firstframe + pc;
 127                 uint64_t msize = core.mlogic->get_mfile().input->size();
 128                 if(minframe > msize || firstframe >= msize)
 129                         throw std::runtime_error("Can not edit finished movie");
 130                 if(frame < minframe)
 131                         throw std::runtime_error("Can not edit past");
 132         }
 133
 134         int current_first_subframe(lua::state& L, lua::parameters& P)
 135         {
 136                 movie& m = CORE().mlogic->get_movie();
 137                 L.pushnumber(m.get_current_frame_first_subframe());
 138                 return 1;
 139         }
 140
 141         int pollcounter(lua::state& L, lua::parameters& P)
 142         {
 143                 unsigned port, controller, button;
 144
 145                 P(port, controller, button);
 146
 147                 uint32_t ret = 0;
 148                 ret = get_pc_for(port, controller, button);
 149                 L.pushnumber(ret);
 150                 return 1;
 151         }
 152
 153         portctrl::frame_vector& framevector(lua::state& L, lua::parameters& P);
 154
 155         int _copy_movie(lua::state& L, lua::parameters& P)
 156         {
 157                 portctrl::frame_vector& v = framevector(L, P);
 158
 159                 lua::_class<lua_inputmovie>::create(L, v);
 160                 return 1;
 161         }
 162
 163         int _get_frame(lua::state& L, lua::parameters& P)
 164         {
 165                 uint64_t n;
 166                 portctrl::frame_vector& v = framevector(L, P);
 167
 168                 P(n);
 169
 170                 if(n >= v.size())
 171                         throw std::runtime_error("Requested frame outside movie");
 172                 portctrl::frame _f = v[n];
 173                 lua::_class<lua_inputframe>::create(L, _f);
 174                 return 1;
 175         }
 176
 177         int _set_frame(lua::state& L, lua::parameters& P)
 178         {
 179                 auto& core = CORE();
 180                 uint64_t n;
 181                 lua_inputframe* f;
 182                 portctrl::frame_vector& v = framevector(L, P);
 183
 184                 P(n, f);
 185
 186                 if(n >= v.size())
 187                         throw std::runtime_error("Requested frame outside movie");
 188                 //Checks if requested frame is from movie.
 189                 if(&v == core.mlogic->get_mfile().input)
 190                         check_can_edit(0, 0, 0, n);
 191
 192                 v[n] = f->get_frame();
 193
 194                 if(&v == core.mlogic->get_mfile().input) {
 195                         //This can't add frames, so no need to adjust the movie.
 196                         core.supdater->update();
 197                         core.dispatch->status_update();
 198                 }
 199                 return 0;
 200         }
 201
 202         int _get_size(lua::state& L, lua::parameters& P)
 203         {
 204                 portctrl::frame_vector& v = framevector(L, P);
 205
 206                 L.pushnumber(v.size());
 207                 return 1;
 208         }
 209
 210         int _count_frames(lua::state& L, lua::parameters& P)
 211         {
 212                 portctrl::frame_vector& v = framevector(L, P);
 213
 214                 L.pushnumber(v.count_frames());
 215                 return 1;
 216         }
 217
 218         int _find_frame(lua::state& L, lua::parameters& P)
 219         {
 220                 uint64_t n;
 221                 portctrl::frame_vector& v = framevector(L, P);
 222
 223                 P(n);
 224
 225                 L.pushnumber(v.find_frame(n));
 226                 return 1;
 227         }
 228
 229         int _subframe_to_frame(lua::state& L, lua::parameters& P)
 230         {
 231                 uint64_t n;
 232                 portctrl::frame_vector& v = framevector(L, P);
 233
 234                 P(n);
 235
 236                 L.pushnumber(v.subframe_to_frame(n));
 237                 return 1;
 238         }
 239
 240         int _blank_frame(lua::state& L, lua::parameters& P)
 241         {
 242                 portctrl::frame_vector& v = framevector(L, P);
 243
 244                 portctrl::frame _f = v.blank_frame(true);
 245                 lua::_class<lua_inputframe>::create(L, _f);
 246                 return 1;
 247         }
 248
 249         int _append_frames(lua::state& L, lua::parameters& P)
 250         {
 251                 auto& core = CORE();
 252                 uint64_t count;
 253                 portctrl::frame_vector& v = framevector(L, P);
 254
 255                 P(count);
 256
 257                 {
 258                         portctrl::frame_vector::notify_freeze freeze(v);
 259                         for(uint64_t i = 0; i < count; i++)
 260                                 v.append(v.blank_frame(true));
 261                 }
 262                 if(&v == core.mlogic->get_mfile().input) {
 263                         core.supdater->update();
 264                         core.dispatch->status_update();
 265                 }
 266                 return 0;
 267         }
 268
 269         int _append_frame(lua::state& L, lua::parameters& P)
 270         {
 271                 auto& core = CORE();
 272                 lua_inputframe* f;
 273                 portctrl::frame_vector& v = framevector(L, P);
 274
 275                 P(f);
 276
 277                 v.append(v.blank_frame(true));
 278                 if(&v == core.mlogic->get_mfile().input) {
 279                         core.supdater->update();
 280                         core.dispatch->status_update();
 281                         check_can_edit(0, 0, 0, v.size() - 1);
 282                 }
 283                 v[v.size() - 1] = f->get_frame();
 284                 if(&v == core.mlogic->get_mfile().input) {
 285                         if(!v[v.size() - 1].sync()) {
 286                                 core.supdater->update();
 287                         }
 288                         core.dispatch->status_update();
 289                 }
 290                 return 0;
 291         }
 292
 293         int _truncate(lua::state& L, lua::parameters& P)
 294         {
 295                 auto& core = CORE();
 296                 uint64_t n;
 297                 portctrl::frame_vector& v = framevector(L, P);
 298
 299                 P(n);
 300
 301                 if(n > v.size())
 302                         throw std::runtime_error("Requested truncate length longer than existing");
 303                 if(&v == core.mlogic->get_mfile().input)
 304                         check_can_edit(0, 0, 0, n);
 305                 v.resize(n);
 306                 if(&v == core.mlogic->get_mfile().input) {
 307                         core.supdater->update();
 308                         core.dispatch->status_update();
 309                 }
 310                 return 0;
 311         }
 312
 313         int _edit(lua::state& L, lua::parameters& P)
 314         {
 315                 auto& core = CORE();
 316                 uint64_t frame;
 317                 unsigned port, controller, button;
 318                 short value;
 319                 portctrl::frame_vector& v = framevector(L, P);
 320
 321                 P(frame, port, controller, button);
 322                 if(P.is_boolean()) value = P.arg<bool>() ? 1 : 0;
 323                 else if(P.is_number()) P(value);
 324                 else
 325                         P.expected("number or boolean");
 326
 327                 if(&v == core.mlogic->get_mfile().input)
 328                         check_can_edit(port, controller, button, frame);
 329                 v[frame].axis3(port, controller, button, value);
 330
 331                 if(&v == core.mlogic->get_mfile().input) {
 332                         core.supdater->update();
 333                         core.dispatch->status_update();
 334                 }
 335                 return 0;
 336         }
 337
 338         template<bool same>
 339         int _copy_frames(lua::state& L, lua::parameters& P)
 340         {
 341                 auto& core = CORE();
 342                 uint64_t dst, src, count;
 343                 bool backwards = same;
 344
 345                 portctrl::frame_vector& dstv = framevector(L, P);
 346                 P(dst);
 347                 portctrl::frame_vector& srcv = same ? dstv : framevector(L, P);
 348                 P(src, count);
 349                 if(same) P(backwards);
 350
 351                 if(src >= srcv.size() || src + count < src)
 352                         throw std::runtime_error("Source index out of movie");
 353                 if(dst > dstv.size() || dst + count < dst)
 354                         throw std::runtime_error("Destination index out of movie");
 355
 356                 if(&dstv == core.mlogic->get_mfile().input)
 357                         check_can_edit(0, 0, 0, dst, true);
 358
 359                 {
 360                         portctrl::frame_vector::notify_freeze freeze(dstv);
 361                         //Add enough blank frames to make the copy.
 362                         while(dst + count > dstv.size())
 363                                 dstv.append(dstv.blank_frame(false));
 364
 365                         for(uint64_t i = backwards ? (count - 1) : 0; i < count; i = backwards ? (i - 1) : (i + 1))
 366                                 dstv[dst + i] = srcv[src + i];
 367                 }
 368                 if(&dstv == core.mlogic->get_mfile().input) {
 369                         core.supdater->update();
 370                         core.dispatch->status_update();
 371                 }
 372                 return 0;
 373         }
 374
 375         int _serialize(lua::state& L, lua::parameters& P)
 376         {
 377                 std::string filename;
 378                 bool binary;
 379
 380                 portctrl::frame_vector& v = framevector(L, P);
 381
 382                 P(filename, binary);
 383
 384                 std::ofstream file(filename, binary ? std::ios_base::binary : std::ios_base::out);
 385                 if(!file)
 386                         throw std::runtime_error("Can't open file to write output to");
 387                 if(binary) {
 388                         uint64_t stride = v.get_stride();
 389                         uint64_t pageframes = v.get_frames_per_page();
 390                         uint64_t vsize = v.size();
 391                         size_t pagenum = 0;
 392                         while(vsize > 0) {
 393                                 uint64_t count = (vsize > pageframes) ? pageframes : vsize;
 394                                 size_t bytes = count * stride;
 395                                 unsigned char* content = v.get_page_buffer(pagenum++);
 396                                 file.write(reinterpret_cast<char*>(content), bytes);
 397                                 vsize -= count;
 398                         }
 399                 } else {
 400                         char buf[MAX_SERIALIZED_SIZE];
 401                         for(uint64_t i = 0; i < v.size(); i++) {
 402                                 v[i].serialize(buf);
 403                                 file << buf << std::endl;
 404                         }
 405                 }
 406                 return 0;
 407         }
 408
 409         class lua_inputmovie
 410         {
 411         public:
 412                 lua_inputmovie(lua::state& L, const portctrl::frame_vector& _v);
 413                 lua_inputmovie(lua::state& L, portctrl::frame& _f);
 414                 static size_t overcommit(const portctrl::frame_vector& _v) { return 0; }
 415                 static size_t overcommit(portctrl::frame& _f) { return 0; }
 416                 int copy_movie(lua::state& L, lua::parameters& P)
 417                 {
 418                         return _copy_movie(L, P);
 419                 }
 420                 int get_frame(lua::state& L, lua::parameters& P)
 421                 {
 422                         return _get_frame(L, P);
 423                 }
 424                 int set_frame(lua::state& L, lua::parameters& P)
 425                 {
 426                         return _set_frame(L, P);
 427                 }
 428                 int get_size(lua::state& L, lua::parameters& P)
 429                 {
 430                         return _get_size(L, P);
 431                 }
 432                 int count_frames(lua::state& L, lua::parameters& P)
 433                 {
 434                         return _count_frames(L, P);
 435                 }
 436                 int find_frame(lua::state& L, lua::parameters& P)
 437                 {
 438                         return _find_frame(L, P);
 439                 }
 440                 int subframe_to_frame(lua::state& L, lua::parameters& P)
 441                 {
 442                         return _subframe_to_frame(L, P);
 443                 }
 444                 int blank_frame(lua::state& L, lua::parameters& P)
 445                 {
 446                         return _blank_frame(L, P);
 447                 }
 448                 int append_frames(lua::state& L, lua::parameters& P)
 449                 {
 450                         return _append_frames(L, P);
 451                 }
 452                 int append_frame(lua::state& L, lua::parameters& P)
 453                 {
 454                         return _append_frame(L, P);
 455                 }
 456                 int truncate(lua::state& L, lua::parameters& P)
 457                 {
 458                         return _truncate(L, P);
 459                 }
 460                 int edit(lua::state& L, lua::parameters& P)
 461                 {
 462                         return _edit(L, P);
 463                 }
 464                 int copy_frames(lua::state& L, lua::parameters& P)
 465                 {
 466                         return _copy_frames<true>(L, P);
 467                 }
 468                 int serialize(lua::state& L, lua::parameters& P)
 469                 {
 470                         return _serialize(L, P);
 471                 }
 472                 int debugdump(lua::state& L, lua::parameters& P)
 473                 {
 474                         char buf[MAX_SERIALIZED_SIZE];
 475                         for(uint64_t i = 0; i < v.size(); i++) {
 476                                 v[i].serialize(buf);
 477                                 messages << buf << std::endl;
 478                         }
 479                         return 0;
 480                 }
 481                 portctrl::frame_vector* get_frame_vector()
 482                 {
 483                         return &v;
 484                 }
 485                 std::string print()
 486                 {
 487                         size_t s = v.size();
 488                         return (stringfmt() << s << " " << ((s != 1) ? "frames" : "frame")).str();
 489                 }
 490         private:
 491                 void common_init(lua::state& L);
 492                 portctrl::frame_vector v;
 493         };
 494
 495         int copy_movie(lua::state& L, lua::parameters& P)
 496         {
 497                 return _copy_movie(L, P);
 498         }
 499
 500         int get_frame(lua::state& L, lua::parameters& P)
 501         {
 502                 return _get_frame(L, P);
 503         }
 504
 505         int set_frame(lua::state& L, lua::parameters& P)
 506         {
 507                 return _set_frame(L, P);
 508         }
 509
 510         int get_size(lua::state& L, lua::parameters& P)
 511         {
 512                 return _get_size(L, P);
 513         }
 514
 515         int count_frames(lua::state& L, lua::parameters& P)
 516         {
 517                 return _count_frames(L, P);
 518         }
 519
 520         int find_frame(lua::state& L, lua::parameters& P)
 521         {
 522                 return _find_frame(L, P);
 523         }
 524
 525         int subframe_to_frame(lua::state& L, lua::parameters& P)
 526         {
 527                 return _subframe_to_frame(L, P);
 528         }
 529
 530         int blank_frame(lua::state& L, lua::parameters& P)
 531         {
 532                 return _blank_frame(L, P);
 533         }
 534
 535         int append_frames(lua::state& L, lua::parameters& P)
 536         {
 537                 return _append_frames(L, P);
 538         }
 539
 540         int append_frame(lua::state& L, lua::parameters& P)
 541         {
 542                 return _append_frame(L, P);
 543         }
 544
 545         int truncate(lua::state& L, lua::parameters& P)
 546         {
 547                 return _truncate(L, P);
 548         }
 549
 550         int edit(lua::state& L, lua::parameters& P)
 551         {
 552                 return _edit(L, P);
 553         }
 554
 555         int copy_frames2(lua::state& L, lua::parameters& P)
 556         {
 557                 return _copy_frames<false>(L, P);
 558         }
 559
 560         int copy_frames(lua::state& L, lua::parameters& P)
 561         {
 562                 return _copy_frames<true>(L, P);
 563         }
 564
 565         int serialize(lua::state& L, lua::parameters& P)
 566         {
 567                 return _serialize(L, P);
 568         }
 569
 570         int unserialize(lua::state& L, lua::parameters& P)
 571         {
 572                 lua_inputframe* f;
 573                 std::string filename;
 574                 bool binary;
 575
 576                 P(f, filename, binary);
 577
 578                 std::ifstream file(filename, binary ? std::ios_base::binary : std::ios_base::in);
 579                 if(!file)
 580                         throw std::runtime_error("Can't open file to read input from");
 581                 lua_inputmovie* m = lua::_class<lua_inputmovie>::create(L, f->get_frame());
 582                 portctrl::frame_vector& v = *m->get_frame_vector();
 583                 portctrl::frame_vector::notify_freeze freeze(v);
 584                 if(binary) {
 585                         uint64_t stride = v.get_stride();
 586                         uint64_t pageframes = v.get_frames_per_page();
 587                         uint64_t vsize = 0;
 588                         size_t pagenum = 0;
 589                         size_t pagesize = stride * pageframes;
 590                         while(file) {
 591                                 v.resize(vsize + pageframes);
 592                                 unsigned char* contents = v.get_page_buffer(pagenum++);
 593                                 file.read(reinterpret_cast<char*>(contents), pagesize);
 594                                 vsize += (file.gcount() / stride);
 595                         }
 596                         v.resize(vsize);
 597                 } else {
 598                         std::string line;
 599                         portctrl::frame tmpl = v.blank_frame(false);
 600                         while(file) {
 601                                 std::getline(file, line);
 602                                 istrip_CR(line);
 603                                 if(line.length() == 0)
 604                                         continue;
 605                                 tmpl.deserialize(line.c_str());
 606                                 v.append(tmpl);
 607                         }
 608                 }
 609                 return 1;
 610         }
 611
 612         int current_branch(lua::state& L, lua::parameters& P)
 613         {
 614                 L.pushlstring(CORE().mlogic->get_mfile().current_branch());
 615                 return 1;
 616         }
 617
 618         int get_branches(lua::state& L, lua::parameters& P)
 619         {
 620                 auto& core = CORE();
 621                 for(auto& i : core.mlogic->get_mfile().branches)
 622                         L.pushlstring(i.first);
 623                 return core.mlogic->get_mfile().branches.size();
 624         }
 625
 626         portctrl::frame_vector& framevector(lua::state& L, lua::parameters& P)
 627         {
 628                 auto& core = CORE();
 629                 if(P.is_nil()) {
 630                         P.skip();
 631                         return *core.mlogic->get_mfile().input;
 632                 } else if(P.is_string()) {
 633                         std::string x;
 634                         P(x);
 635                         if(!core.mlogic->get_mfile().branches.count(x))
 636                                 throw std::runtime_error("No such branch");
 637                         return core.mlogic->get_mfile().branches[x];
 638                 } else if(P.is<lua_inputmovie>())
 639                         return *(P.arg<lua_inputmovie*>()->get_frame_vector());
 640                 else
 641                         return *core.mlogic->get_mfile().input;
 642         }
 643
 644         lua::_class<lua_inputmovie> LUA_class_inputmovie(lua_class_movie, "INPUTMOVIE", {}, {
 645                         {"copy_movie", &lua_inputmovie::copy_movie},
 646                         {"get_frame", &lua_inputmovie::get_frame},
 647                         {"set_frame", &lua_inputmovie::set_frame},
 648                         {"get_size", &lua_inputmovie::get_size},
 649                         {"count_frames", &lua_inputmovie::count_frames},
 650                         {"find_frame", &lua_inputmovie::find_frame},
 651                         {"subframe_to_frame", &lua_inputmovie::subframe_to_frame},
 652                         {"blank_frame", &lua_inputmovie::blank_frame},
 653                         {"append_frames", &lua_inputmovie::append_frames},
 654                         {"append_frame", &lua_inputmovie::append_frame},
 655                         {"truncate", &lua_inputmovie::truncate},
 656                         {"edit", &lua_inputmovie::edit},
 657                         {"debugdump", &lua_inputmovie::debugdump},
 658                         {"copy_frames", &lua_inputmovie::copy_frames},
 659                         {"serialize", &lua_inputmovie::serialize},
 660         }, &lua_inputmovie::print);
 661
 662         lua::_class<lua_inputframe> LUA_class_inputframe(lua_class_movie, "INPUTFRAME", {}, {
 663                         {"get_button", &lua_inputframe::get_button},
 664                         {"get_axis", &lua_inputframe::get_axis},
 665                         {"set_axis", &lua_inputframe::set_axis},
 666                         {"set_button", &lua_inputframe::set_axis},
 667                         {"serialize", &lua_inputframe::serialize},
 668                         {"unserialize", &lua_inputframe::unserialize},
 669                         {"get_stride", &lua_inputframe::get_stride},
 670         }, &lua_inputframe::print);
 671
 672         lua::functions LUA_inputmovie_fns(lua_func_misc, "movie", {
 673                 {"current_first_subframe", current_first_subframe},
 674                 {"pollcounter", pollcounter},
 675                 {"copy_movie", copy_movie},
 676                 {"get_frame", get_frame},
 677                 {"set_frame", set_frame},
 678                 {"get_size", get_size},
 679                 {"count_frames", count_frames},
 680                 {"find_frame", find_frame},
 681                 {"subframe_to_frame", subframe_to_frame},
 682                 {"blank_frame", blank_frame},
 683                 {"append_frames", append_frames},
 684                 {"append_frame", append_frame},
 685                 {"truncate", truncate},
 686                 {"edit", edit},
 687                 {"copy_frames2", copy_frames2},
 688                 {"copy_frames", copy_frames},
 689                 {"serialize", serialize},
 690                 {"unserialize", unserialize},
 691                 {"current_branch", current_branch},
 692                 {"get_branches", get_branches},
 693         });
 694
 695         lua_inputframe::lua_inputframe(lua::state& L, portctrl::frame _f)
 696         {
 697                 f = _f;
 698         }
 699
 700         void lua_inputmovie::common_init(lua::state& L)
 701         {
 702         }
 703
 704         lua_inputmovie::lua_inputmovie(lua::state& L, const portctrl::frame_vector& _v)
 705         {
 706                 v = _v;
 707                 common_init(L);
 708         }
 709
 710         lua_inputmovie::lua_inputmovie(lua::state& L, portctrl::frame& f)
 711         {
 712                 v.clear(f.porttypes());
 713                 common_init(L);
 714         }
 715 }