src/lua/inputmovie.cpp

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