include/core/controllerframe.hpp

   1 #ifndef _controllerframe__hpp__included__
   2 #define _controllerframe__hpp__included__
   3
   4 #include <cstring>
   5 #include <cstdlib>
   6 #include <cstdint>
   7 #include <stdexcept>
   8 #include <string>
   9 #include <vector>
  10 #include <map>
  11 #include <set>
  12
  13 /**
  14  * For now, reserve 20 bytes, for:
  15  *
  16  * - 5 bytes for system.
  17  * - 6 bytes for port 1 (multitap).
  18  * - 9 bytes for port 2 (justifiers).
  19  */
  20 #define MAXIMUM_CONTROLLER_FRAME_SIZE 20
  21
  22 /**
  23  * Maximum amount of data controller_frame::display() can write.
  24  */
  25 #define MAX_DISPLAY_LENGTH 128
  26 /**
  27  * Maximum amount of data controller_frame::serialize() can write.
  28  */
  29 #define MAX_SERIALIZED_SIZE 256
  30 /**
  31  * Maximum number of ports.
  32  */
  33 #define MAX_PORTS 2
  34 /**
  35  * Maximum number of controllers per one port.
  36  */
  37 #define MAX_CONTROLLERS_PER_PORT 4
  38 /**
  39  * Maximum numbers of controls per one controller.
  40  */
  41 #define MAX_CONTROLS_PER_CONTROLLER 12
  42 /**
  43  * Number of button controls.
  44  */
  45 #define MAX_BUTTONS MAX_PORTS * MAX_CONTROLLERS_PER_PORT * MAX_CONTROLS_PER_CONTROLLER
  46 /**
  47  * Size of controller page.
  48  */
  49 #define CONTROLLER_PAGE_SIZE 65500
  50 /**
  51  * Special return value for deserialize() indicating no input was taken.
  52  */
  53 #define DESERIALIZE_SPECIAL_BLANK 0xFFFFFFFFUL
  54 /**
  55  * Analog indices.
  56  */
  57 #define MAX_ANALOG 3
  58 /**
  59  * Logical button IDs.
  60  */
  61 #define LOGICAL_BUTTON_LEFT 0
  62 #define LOGICAL_BUTTON_RIGHT 1
  63 #define LOGICAL_BUTTON_UP 2
  64 #define LOGICAL_BUTTON_DOWN 3
  65 #define LOGICAL_BUTTON_A 4
  66 #define LOGICAL_BUTTON_B 5
  67 #define LOGICAL_BUTTON_X 6
  68 #define LOGICAL_BUTTON_Y 7
  69 #define LOGICAL_BUTTON_L 8
  70 #define LOGICAL_BUTTON_R 9
  71 #define LOGICAL_BUTTON_SELECT 10
  72 #define LOGICAL_BUTTON_START 11
  73 #define LOGICAL_BUTTON_TRIGGER 12
  74 #define LOGICAL_BUTTON_CURSOR 13
  75 #define LOGICAL_BUTTON_TURBO 14
  76 #define LOGICAL_BUTTON_PAUSE 15
  77 #define MAX_LOGICAL_BUTTONS 16
  78
  79 /**
  80  * Get name of logical button.
  81  *
  82  * Parameter lbid: ID of logical button.
  83  * Returns: The name of button.
  84  * Throws std::bad_alloc: Not enough memory.
  85  */
  86 std::string get_logical_button_name(unsigned lbid) throw(std::bad_alloc);
  87
  88 /**
  89  * This enumeration gives the type of port.
  90  */
  91 enum porttype_t
  92 {
  93 /**
  94  * No device
  95  */
  96         PT_NONE = 0,                    //Nothing connected to port.
  97 /**
  98  * Gamepad
  99  */
 100         PT_GAMEPAD = 1,
 101 /**
 102  * Multitap (with 4 gamepads connected)
 103  */
 104         PT_MULTITAP = 2,
 105 /**
 106  * Mouse
 107  */
 108         PT_MOUSE = 3,
 109 /**
 110  * Superscope (only allowed for port 2).
 111  */
 112         PT_SUPERSCOPE = 4,
 113 /**
 114  * Justifier (only allowed for port 2).
 115  */
 116         PT_JUSTIFIER = 5,
 117 /**
 118  * 2 Justifiers (only allowed for port 2).
 119  */
 120         PT_JUSTIFIERS = 6,
 121 /**
 122  * Number of controller types.
 123  */
 124         PT_LAST_CTYPE = 6,
 125 /**
 126  * Invalid controller type.
 127  */
 128         PT_INVALID = PT_LAST_CTYPE + 1
 129 };
 130
 131 /**
 132  * This enumeration gives the type of device.
 133  */
 134 enum devicetype_t
 135 {
 136 /**
 137  * No device
 138  */
 139         DT_NONE = 0,
 140 /**
 141  * Gamepad (note that multitap controllers are gamepads)
 142  */
 143         DT_GAMEPAD = 1,
 144 /**
 145  * Mouse
 146  */
 147         DT_MOUSE = 3,
 148 /**
 149  * Superscope
 150  */
 151         DT_SUPERSCOPE = 4,
 152 /**
 153  * Justifier (note that justifiers is two of these).
 154  */
 155         DT_JUSTIFIER = 5
 156 };
 157
 158 /**
 159  * Is not field terminator.
 160  *
 161  * Parameter ch: The character.
 162  * Returns: True if character is not terminator, false if character is terminator.
 163  */
 164 inline bool is_nonterminator(char ch) throw()
 165 {
 166         return (ch != '|' && ch != '\r' && ch != '\n' && ch != '\0');
 167 }
 168
 169 /**
 170  * Read button value.
 171  *
 172  * Parameter buf: Buffer to read from.
 173  * Parameter idx: Index to buffer. Updated.
 174  * Returns: The read value.
 175  */
 176 inline bool read_button_value(const char* buf, size_t& idx) throw()
 177 {
 178         char ch = buf[idx];
 179         if(is_nonterminator(ch))
 180                 idx++;
 181         return (ch != '|' && ch != '\r' && ch != '\n' && ch != '\0' && ch != '.' && ch != ' ' && ch != '\t');
 182 }
 183
 184 /**
 185  * Read axis value.
 186  *
 187  * Parameter buf: Buffer to read from.
 188  * Parameter idx: Index to buffer. Updated.
 189  * Returns: The read value.
 190  */
 191 short read_axis_value(const char* buf, size_t& idx) throw();
 192
 193 /**
 194  * Skip whitespace.
 195  *
 196  * Parameter buf: Buffer to read from.
 197  * Parameter idx: Index to buffer. Updated.
 198  */
 199 inline void skip_field_whitespace(const char* buf, size_t& idx) throw()
 200 {
 201         while(buf[idx] == ' ' || buf[idx] == '\t')
 202                 idx++;
 203 }
 204
 205 /**
 206  * Skip rest of the field.
 207  *
 208  * Parameter buf: Buffer to read from.
 209  * Parameter idx: Index to buffer. Updated.
 210  * Parameter include_pipe: If true, also skip the '|'.
 211  */
 212 inline void skip_rest_of_field(const char* buf, size_t& idx, bool include_pipe) throw()
 213 {
 214         while(is_nonterminator(buf[idx]))
 215                 idx++;
 216         if(include_pipe && buf[idx] == '|')
 217                 idx++;
 218 }
 219
 220 /**
 221  * Serialize short.
 222  */
 223 inline void serialize_short(unsigned char* buf, short val)
 224 {
 225         buf[0] = static_cast<unsigned short>(val) >> 8;
 226         buf[1] = static_cast<unsigned short>(val);
 227 }
 228
 229 /**
 230  * Serialize short.
 231  */
 232 inline short unserialize_short(const unsigned char* buf)
 233 {
 234         return static_cast<short>((static_cast<unsigned short>(buf[0]) << 8) | static_cast<unsigned short>(buf[1]));
 235 }
 236
 237 /**
 238  * Information about port type.
 239  */
 240 struct porttype_info
 241 {
 242 /**
 243  * Look up information about port type.
 244  *
 245  * Parameter p: The port type.
 246  * Returns: Infor about port type.
 247  * Throws std::runtime_error: Invalid port type.
 248  */
 249         static const porttype_info& lookup(porttype_t p) throw(std::runtime_error);
 250 /**
 251  * Look up information about port type.
 252  *
 253  * Parameter p: The port type string.
 254  * Returns: Infor about port type.
 255  * Throws std::runtime_error: Invalid port type.
 256  */
 257         static const porttype_info& lookup(const std::string& p) throw(std::runtime_error);
 258 /**
 259  * Register port type.
 260  *
 261  * Parameter ptype: Type value for port type.
 262  * Parameter pname: The name of port type.
 263  * Parameter psize: The size of storage for this type.
 264  * Throws std::bad_alloc: Not enough memory.
 265  */
 266         porttype_info(porttype_t ptype, const std::string& pname, size_t psize) throw(std::bad_alloc);
 267 /**
 268  * Unregister port type.
 269  */
 270         ~porttype_info() throw();
 271 /**
 272  * Writes controller data into compressed representation.
 273  *
 274  * Parameter buffer: The buffer storing compressed representation of controller state.
 275  * Parameter idx: Index of controller.
 276  * Parameter ctrl: The control to manipulate.
 277  * Parameter x: New value for control. Only zero/nonzero matters for buttons.
 278  */
 279         virtual void write(unsigned char* buffer, unsigned idx, unsigned ctrl, short x) const throw() = 0;
 280 /**
 281  * Read controller data from compressed representation.
 282  *
 283  * Parameter buffer: The buffer storing compressed representation of controller state.
 284  * Parameter idx: Index of controller.
 285  * Parameter ctrl: The control to query.
 286  * Returns: The value of control. Buttons return 0 or 1.
 287  */
 288         virtual short read(const unsigned char* buffer, unsigned idx, unsigned ctrl) const  throw() = 0;
 289 /**
 290  * Format compressed controller data into input display.
 291  *
 292  * Parameter buffer: The buffer storing compressed representation of controller state.
 293  * Parameter idx: Index of controller.
 294  * Parameter buf: The buffer to write NUL-terminated display string to. Assumed to be MAX_DISPLAY_LENGTH bytes in size.
 295  */
 296         virtual void display(const unsigned char* buffer, unsigned idx, char* buf) const  throw() = 0;
 297 /**
 298  * Take compressed controller data and serialize it into textual representation.
 299  *
 300  * - The initial '|' is also written.
 301  *
 302  * Parameter buffer: The buffer storing compressed representation of controller state.
 303  * Parameter textbuf: The text buffer to write to.
 304  * Returns: Number of bytes written.
 305  */
 306         virtual size_t serialize(const unsigned char* buffer, char* textbuf) const  throw() = 0;
 307 /**
 308  * Unserialize textual representation into compressed controller state.
 309  *
 310  * - Only stops reading on '|', NUL, CR or LF in the final read field. That byte is not read.
 311  *
 312  * Parameter buffer: The buffer storing compressed representation of controller state.
 313  * Parameter textbuf: The text buffer to read.
 314  * Returns: Number of bytes read.
 315  * Throws std::runtime_error: Bad serialization.
 316  */
 317         virtual size_t deserialize(unsigned char* buffer, const char* textbuf) const  throw() = 0;
 318 /**
 319  * Return device type for given index.
 320  *
 321  * Parameter idx: The index of controller.
 322  * Returns: The type of device.
 323  */
 324         virtual devicetype_t devicetype(unsigned idx) const  throw() = 0;
 325 /**
 326  * Number of controllers connected to this port.
 327  */
 328         virtual unsigned controllers() const  throw() = 0;
 329 /**
 330  * Internal type value for port.
 331  */
 332         virtual unsigned internal_type() const  throw() = 0;
 333 /**
 334  * Return if type is legal for port.
 335  *
 336  * Parameter port: Number of port.
 337  * Returns: True if legal, false if not.
 338  */
 339         virtual bool legal(unsigned port) const  throw() = 0;
 340 /**
 341  * Translate controller and logical button id pair into physical button id.
 342  *
 343  * Parameter controller: The number of controller.
 344  * Parameter lbid: Logigal button ID.
 345  * Returns: The physical button ID, or -1 if no such button exists.
 346  */
 347         virtual int button_id(unsigned controller, unsigned lbid) const throw() = 0;
 348 /**
 349  * Set this controller as core controller.
 350  *
 351  * Parameter port: Port to set to.
 352  */
 353         virtual void set_core_controller(unsigned port) const throw() = 0;
 354 /**
 355  * Does the controller have analog function?
 356  *
 357  * Parameter controller: Controller number.
 358  */
 359         virtual bool is_analog(unsigned controller) const throw() = 0;
 360 /**
 361  * Does the controller have mouse-type function?
 362  *
 363  * Parameter controller: Controller number.
 364  */
 365         virtual bool is_mouse(unsigned controller) const throw() = 0;
 366 /**
 367  * Port type value.
 368  */
 369         porttype_t value;
 370 /**
 371  * Number of bytes it takes to store this.
 372  */
 373         size_t storage_size;
 374 /**
 375  * Name of port type.
 376  */
 377         std::string name;
 378 private:
 379         porttype_info(const porttype_info&);
 380         porttype_info& operator=(const porttype_info&);
 381 };
 382
 383 /**
 384  * Poll counter vector.
 385  */
 386 class pollcounter_vector
 387 {
 388 public:
 389 /**
 390  * Create new pollcounter vector filled with all zeroes and all DRDY bits clear.
 391  */
 392         pollcounter_vector() throw();
 393 /**
 394  * Zero all poll counters and clear all DRDY bits. System flag is cleared.
 395  */
 396         void clear() throw();
 397 /**
 398  * Set all DRDY bits.
 399  */
 400         void set_all_DRDY() throw();
 401 /**
 402  * Clear specified DRDY bit.
 403  *
 404  * Parameter pcid: The physical controller id.
 405  * Parameter ctrl: The control id.
 406  */
 407         void clear_DRDY(unsigned pcid, unsigned ctrl) throw();
 408 /**
 409  * Get state of DRDY bit.
 410  *
 411  * Parameter pcid: The physical controller id.
 412  * Parameter ctrl: The control id.
 413  * Returns: The DRDY state.
 414  */
 415         bool get_DRDY(unsigned pcid, unsigned ctrl) throw();
 416 /**
 417  * Get state of DRDY bit.
 418  *
 419  * Parameter idx: The control index.
 420  * Returns: The DRDY state.
 421  */
 422         bool get_DRDY(unsigned idx) throw()
 423         {
 424                 return get_DRDY(idx / MAX_CONTROLS_PER_CONTROLLER, idx % MAX_CONTROLS_PER_CONTROLLER);
 425         }
 426 /**
 427  * Is any poll count nonzero or is system flag set?
 428  *
 429  * Returns: True if at least one poll count is nonzero or if system flag is set. False otherwise.
 430  */
 431         bool has_polled() throw();
 432 /**
 433  * Read the actual poll count on specified control.
 434  *
 435  * Parameter pcid: The physical controller id.
 436  * Parameter ctrl: The control id.
 437  * Return: The poll count.
 438  */
 439         uint32_t get_polls(unsigned pcid, unsigned ctrl) throw();
 440 /**
 441  * Read the actual poll count on specified control.
 442  *
 443  * Parameter idx: The control index.
 444  * Return: The poll count.
 445  */
 446         uint32_t get_polls(unsigned idx) throw()
 447         {
 448                 return get_polls(idx / MAX_CONTROLS_PER_CONTROLLER, idx % MAX_CONTROLS_PER_CONTROLLER);
 449         }
 450 /**
 451  * Increment poll count on specified control.
 452  *
 453  * Parameter pcid: The physical controller id.
 454  * Parameter ctrl: The control id.
 455  * Return: The poll count pre-increment.
 456  */
 457         uint32_t increment_polls(unsigned pcid, unsigned ctrl) throw();
 458 /**
 459  * Set the system flag.
 460  */
 461         void set_system() throw();
 462 /**
 463  * Get the system flag.
 464  *
 465  * Returns: The state of system flag.
 466  */
 467         bool get_system() throw();
 468 /**
 469  * Get highest poll counter value.
 470  *
 471  * - System flag counts as 1 poll.
 472  *
 473  * Returns: The maximum poll count (at least 1 if system flag is set).
 474  */
 475         uint32_t max_polls() throw();
 476 /**
 477  * Save state to memory block.
 478  *
 479  * Parameter mem: The memory block to save to.
 480  * Throws std::bad_alloc: Not enough memory.
 481  */
 482         void save_state(std::vector<uint32_t>& mem) throw(std::bad_alloc);
 483 /**
 484  * Load state from memory block.
 485  *
 486  * Parameter mem: The block from restore from.
 487  */
 488         void load_state(const std::vector<uint32_t>& mem) throw();
 489 /**
 490  * Check if state can be loaded without errors.
 491  *
 492  * Returns: True if load is possible, false otherwise.
 493  */
 494         bool check(const std::vector<uint32_t>& mem) throw();
 495 private:
 496         uint32_t ctrs[MAX_BUTTONS];
 497         bool system_flag;
 498 };
 499
 500 /**
 501  * Single (sub)frame of controls.
 502  */
 503 class controller_frame
 504 {
 505 public:
 506 /**
 507  * Default constructor. Invalid port types, dedicated memory.
 508  */
 509         controller_frame() throw();
 510 /**
 511  * Create subframe of controls with specified controller types and dedicated memory.
 512  *
 513  * Parameter p1: Type of port1.
 514  * Parameter p2: Type of port2.
 515  *
 516  * Throws std::runtime_error: Invalid port type.
 517  */
 518         controller_frame(porttype_t p1, porttype_t p2) throw(std::runtime_error);
 519 /**
 520  * Create subframe of controls with specified controller types and specified memory.
 521  *
 522  * Parameter memory: The backing memory.
 523  * Parameter p1: Type of port1.
 524  * Parameter p2: Type of port2.
 525  *
 526  * Throws std::runtime_error: Invalid port type or NULL memory.
 527  */
 528         controller_frame(unsigned char* memory, porttype_t p1 = PT_GAMEPAD, porttype_t p2 = PT_NONE)
 529                 throw(std::runtime_error);
 530 /**
 531  * Copy construct a frame. The memory will be dedicated.
 532  *
 533  * Parameter obj: The object to copy.
 534  */
 535         controller_frame(const controller_frame& obj) throw();
 536 /**
 537  * Assign a frame. The types must either match or memory must be dedicated.
 538  *
 539  * Parameter obj: The object to copy.
 540  * Returns: Reference to this.
 541  * Throws std::runtime_error: The types don't match and memory is not dedicated.
 542  */
 543         controller_frame& operator=(const controller_frame& obj) throw(std::runtime_error);
 544 /**
 545  * Get type of port.
 546  *
 547  * Parameter port: Number of port.
 548  * Returns: The type of port.
 549  */
 550         porttype_t get_port_type(unsigned port) throw()
 551         {
 552                 return (port < MAX_PORTS) ? types[port] : PT_NONE;
 553         }
 554 /**
 555  * Get blank dedicated frame of same port types.
 556  *
 557  * Return blank frame.
 558  */
 559         controller_frame blank_frame() throw()
 560         {
 561                 return controller_frame(types[0], types[1]);
 562         }
 563 /**
 564  * Set type of port. Input for that port is zeroized.
 565  *
 566  * Parameter port: Number of port.
 567  * Parameter type: The new type.
 568  * Throws std::runtime_error: Bad port type or non-dedicated memory.
 569  */
 570         void set_port_type(unsigned port, porttype_t ptype) throw(std::runtime_error);
 571 /**
 572  * Check that types match.
 573  *
 574  * Parameter obj: Another object.
 575  * Returns: True if types match, false otherwise.
 576  */
 577         bool types_match(const controller_frame& obj) const throw()
 578         {
 579                 for(size_t i = 0; i < MAX_PORTS; i++)
 580                         if(types[i] != obj.types[i])
 581                                 return false;
 582                 return true;
 583         }
 584 /**
 585  * Perform XOR between controller frames.
 586  *
 587  * Parameter another: The another object.
 588  * Returns: The XOR result (dedicated memory).
 589  * Throws std::runtime_error: Type mismatch.
 590  */
 591         controller_frame operator^(const controller_frame& another) throw(std::runtime_error)
 592         {
 593                 controller_frame x(*this);
 594                 for(size_t i = 0; i < MAX_PORTS; i++)
 595                         if(types[i] != another.types[i])
 596                                 throw std::runtime_error("controller_frame::operator^: Type mismatch");
 597                 for(size_t i = 0; i < totalsize; i++)
 598                         x.backing[i] ^= another.backing[i];
 599                 return x;
 600         }
 601 /**
 602  * Set the sync flag.
 603  *
 604  * Parameter x: The value to set the sync flag to.
 605  */
 606         void sync(bool x) throw()
 607         {
 608                 if(x)
 609                         backing[0] |= 1;
 610                 else
 611                         backing[0] &= ~1;
 612         }
 613 /**
 614  * Get the sync flag.
 615  *
 616  * Return value: Value of sync flag.
 617  */
 618         bool sync() throw()
 619         {
 620                 return ((backing[0] & 1) != 0);
 621         }
 622 /**
 623  * Quick get sync flag for buffer.
 624  */
 625         static bool sync(const unsigned char* mem) throw()
 626         {
 627                 return ((mem[0] & 1) != 0);
 628         }
 629 /**
 630  * Set the reset flag.
 631  *
 632  * Parameter x: The value to set the reset flag to.
 633  */
 634         void reset(bool x) throw()
 635         {
 636                 if(x)
 637                         backing[0] |= 2;
 638                 else
 639                         backing[0] &= ~2;
 640         }
 641 /**
 642  * Get the reset flag.
 643  *
 644  * Return value: Value of resset flag.
 645  */
 646         bool reset() throw()
 647         {
 648                 return ((backing[0] & 2) != 0);
 649         }
 650 /**
 651  * Set the reset delay.
 652  *
 653  * Parameter x: The value to set reset delay to.
 654  */
 655         void delay(std::pair<short, short> x) throw()
 656         {
 657                 backing[1] = static_cast<unsigned short>(x.first) >> 8;
 658                 backing[2] = static_cast<unsigned short>(x.first);
 659                 backing[3] = static_cast<unsigned short>(x.second) >> 8;
 660                 backing[4] = static_cast<unsigned short>(x.second);
 661         }
 662 /**
 663  * Get the reset delay.
 664  *
 665  * Return value: Value of reset delay.
 666  */
 667         std::pair<short, short> delay() throw()
 668         {
 669                 short x, y;
 670                 x = static_cast<short>(static_cast<unsigned short>(backing[1]) << 8);
 671                 x |= static_cast<short>(static_cast<unsigned short>(backing[2]));
 672                 y = static_cast<short>(static_cast<unsigned short>(backing[3]) << 8);
 673                 y |= static_cast<short>(static_cast<unsigned short>(backing[4]));
 674                 return std::make_pair(x, y);
 675         }
 676 /**
 677  * Get size of frame.
 678  *
 679  * Returns: The number of bytes it takes to store frame of this type.
 680  */
 681         size_t size()
 682         {
 683                 return totalsize;
 684         }
 685 /**
 686  * Set axis/button value.
 687  *
 688  * Parameter pcid: Physical controller id.
 689  * Parameter ctrl: The control id.
 690  * Parameter x: The new value.
 691  */
 692         void axis(unsigned pcid, unsigned ctrl, short x) throw()
 693         {
 694                 unsigned port = (pcid / MAX_CONTROLLERS_PER_PORT) % MAX_PORTS;
 695                 pinfo[port]->write(backing + offsets[port], pcid % MAX_CONTROLLERS_PER_PORT, ctrl, x);
 696         }
 697 /**
 698  * Set axis/button value.
 699  *
 700  * Parameter idx: Control index.
 701  * Parameter x: The new value.
 702  */
 703         void axis2(unsigned idx, short x) throw()
 704         {
 705                 axis(idx / MAX_CONTROLS_PER_CONTROLLER, idx % MAX_CONTROLS_PER_CONTROLLER, x);
 706         }
 707 /**
 708  * Get axis/button value.
 709  *
 710  * Parameter pcid: Physical controller id.
 711  * Parameter ctrl: The control id.
 712  * Return value: The axis value.
 713  */
 714         short axis(unsigned pcid, unsigned ctrl) throw()
 715         {
 716                 unsigned port = (pcid / MAX_CONTROLLERS_PER_PORT) % MAX_PORTS;
 717                 return pinfo[port]->read(backing + offsets[port], pcid % MAX_CONTROLLERS_PER_PORT, ctrl);
 718         }
 719
 720 /**
 721  * Get axis/button value.
 722  *
 723  * Parameter idx: Index of control.
 724  * Return value: The axis value.
 725  */
 726         short axis2(unsigned idx) throw()
 727         {
 728                 return axis(idx / MAX_CONTROLS_PER_CONTROLLER, idx % MAX_CONTROLS_PER_CONTROLLER);
 729         }
 730 /**
 731  * Get controller display.
 732  *
 733  * Parameter pcid: Physical controller id.
 734  * Parameter buf: Buffer to write nul-terminated display to.
 735  */
 736         void display(unsigned pcid, char* buf) throw()
 737         {
 738                 unsigned port = (pcid / MAX_CONTROLLERS_PER_PORT) % MAX_PORTS;
 739                 return pinfo[port]->display(backing + offsets[port], pcid % MAX_CONTROLLERS_PER_PORT, buf);
 740         }
 741 /**
 742  * Get device type.
 743  *
 744  * Parameter pcid: Physical controller id.
 745  * Returns: Device type.
 746  */
 747         devicetype_t devicetype(unsigned pcid) throw()
 748         {
 749                 unsigned port = (pcid / MAX_CONTROLLERS_PER_PORT) % MAX_PORTS;
 750                 return pinfo[port]->devicetype(pcid % MAX_CONTROLLERS_PER_PORT);
 751         }
 752 /**
 753  * Deserialize frame from text format.
 754  *
 755  * Parameter buf: The buffer containing text representation. Terminated by NUL, CR or LF.
 756  * Throws std::runtime_error: Bad serialized representation.
 757  */
 758         void deserialize(const char* buf) throw(std::runtime_error)
 759         {
 760                 size_t offset = 0;
 761                 offset += system_deserialize(backing, buf);
 762                 if(buf[offset] == '|')
 763                         offset++;
 764                 for(size_t i = 0; i < MAX_PORTS; i++) {
 765                         size_t s = pinfo[i]->deserialize(backing + offsets[i], buf + offset);
 766                         if(s != DESERIALIZE_SPECIAL_BLANK) {
 767                                 offset += s;
 768                                 if(buf[offset] == '|')
 769                                         offset++;
 770                         }
 771                 }
 772         }
 773 /**
 774  * Serialize frame to text format.
 775  *
 776  * Parameter buf: The buffer to write NUL-terminated text representation to.
 777  */
 778         void serialize(char* buf) throw()
 779         {
 780                 size_t offset = 0;
 781                 offset += system_serialize(backing, buf);
 782                 for(size_t i = 0; i < MAX_PORTS; i++) {
 783                         offset += pinfo[i]->serialize(backing + offsets[i], buf + offset);
 784                         buf[offset++] = (i < MAX_PORTS - 1) ? '|' : '\0';
 785                 }
 786         }
 787 /**
 788  * Return copy with dedicated memory.
 789  *
 790  * Parameter sync: If set, the frame will have sync flag set, otherwise it will have sync flag clear.
 791  * Returns: Copy of this frame.
 792  */
 793         controller_frame copy(bool sync)
 794         {
 795                 controller_frame c(*this);
 796                 c.sync(sync);
 797                 return c;
 798         }
 799 /**
 800  * Compare two frames.
 801  *
 802  * Parameter obj: Another frame.
 803  * Returns: True if equal, false if not.
 804  */
 805         bool operator==(const controller_frame& obj) const throw()
 806         {
 807                 if(!types_match(obj))
 808                         return false;
 809                 return !memcmp(backing, obj.backing, totalsize);
 810         }
 811 /**
 812  * Compare two frames.
 813  *
 814  * Parameter obj: Another frame.
 815  * Returns: True if not equal, false if equal.
 816  */
 817         bool operator!=(const controller_frame& obj) const throw()
 818         {
 819                 return !(*this == obj);
 820         }
 821 /**
 822  * Get physical button ID for physical controller ID and logical button ID.
 823  *
 824  * Parameter pcid: Physical controller id.
 825  * Parameter lbid: Logical button id.
 826  * Returns: The physical button id, or -1 if no such button.
 827  */
 828         int button_id(unsigned pcid, unsigned lbid)
 829         {
 830                 unsigned port = (pcid / MAX_CONTROLLERS_PER_PORT) % MAX_PORTS;
 831                 return pinfo[port]->button_id(pcid % MAX_CONTROLLERS_PER_PORT, lbid);
 832         }
 833 /**
 834  * Does the specified controller have analog function.
 835  *
 836  * Parameter pcid: Physical controller id.
 837  */
 838         bool is_analog(unsigned pcid)
 839         {
 840                 unsigned port = (pcid / MAX_CONTROLLERS_PER_PORT) % MAX_PORTS;
 841                 return pinfo[port]->is_analog(pcid % MAX_CONTROLLERS_PER_PORT);
 842         }
 843 /**
 844  * Does the specified controller have mouse-type function.
 845  *
 846  * Parameter pcid: Physical controller id.
 847  */
 848         bool is_mouse(unsigned pcid)
 849         {
 850                 unsigned port = (pcid / MAX_CONTROLLERS_PER_PORT) % MAX_PORTS;
 851                 return pinfo[port]->is_mouse(pcid % MAX_CONTROLLERS_PER_PORT);
 852         }
 853 private:
 854         size_t totalsize;
 855         unsigned char memory[MAXIMUM_CONTROLLER_FRAME_SIZE];
 856         unsigned char* backing;
 857         porttype_t types[MAX_PORTS];
 858         size_t offsets[MAX_PORTS];
 859         const porttype_info* pinfo[MAX_PORTS];
 860         static size_t system_serialize(const unsigned char* buffer, char* textbuf);
 861         static size_t system_deserialize(unsigned char* buffer, const char* textbuf);
 862         void set_types(const porttype_t* tarr);
 863 };
 864
 865 /**
 866  * Vector of controller frames.
 867  */
 868 class controller_frame_vector
 869 {
 870 public:
 871 /**
 872  * Construct new controller frame vector.
 873  *
 874  * Parameter p1: Type of port 1.
 875  * Parameter p2: Type of port 2.
 876  * Throws std::runtime_error: Illegal port types.
 877  */
 878         controller_frame_vector(enum porttype_t p1 = PT_INVALID, enum porttype_t p2 = PT_INVALID)
 879                 throw(std::runtime_error);
 880 /**
 881  * Destroy controller frame vector
 882  */
 883         ~controller_frame_vector() throw();
 884 /**
 885  * Copy controller frame vector.
 886  *
 887  * Parameter obj: The object to copy.
 888  * Throws std::bad_alloc: Not enough memory.
 889  */
 890         controller_frame_vector(const controller_frame_vector& vector) throw(std::bad_alloc);
 891 /**
 892  * Assign controller frame vector.
 893  *
 894  * Parameter obj: The object to copy.
 895  * Returns: Reference to this.
 896  * Throws std::bad_alloc: Not enough memory.
 897  */
 898         controller_frame_vector& operator=(const controller_frame_vector& vector) throw(std::bad_alloc);
 899 /**
 900  * Blank vector and change the type of ports.
 901  *
 902  * Parameter p1: Type of port 1.
 903  * Parameter p2: Type of port 2.
 904  * Throws std::runtime_error: Illegal port types.
 905  */
 906         void clear(enum porttype_t p1, enum porttype_t p2) throw(std::runtime_error);
 907 /**
 908  * Blank vector.
 909  */
 910         void clear() throw()
 911         {
 912                 clear(types[0], types[1]);
 913         }
 914 /**
 915  * Get number of subframes.
 916  */
 917         size_t size()
 918         {
 919                 return frames;
 920         }
 921 /**
 922  * Access specified subframe.
 923  *
 924  * Parameter x: The frame number.
 925  * Returns: The controller frame.
 926  * Throws std::runtime_error: Invalid frame index.
 927  */
 928         controller_frame operator[](size_t x)
 929         {
 930                 size_t page = x / frames_per_page;
 931                 size_t pageoffset = frame_size * (x % frames_per_page);
 932                 if(x >= frames)
 933                         throw std::runtime_error("controller_frame_vector::operator[]: Illegal index");
 934                 if(page != cache_page_num) {
 935                         cache_page = &pages[page];
 936                         cache_page_num = page;
 937                 }
 938                 return controller_frame(cache_page->content + pageoffset, types[0], types[1]);
 939         }
 940 /**
 941  * Append a subframe.
 942  *
 943  * Parameter frame: The frame to append.
 944  * Throws std::bad_alloc: Not enough memory.
 945  * Throws std::runtime_error: Port type mismatch.
 946  */
 947         void append(controller_frame frame) throw(std::bad_alloc, std::runtime_error);
 948 /**
 949  * Change length of vector.
 950  *
 951  * - Reducing length of vector will discard extra elements.
 952  * - Extending length of vector will add all-zero elements.
 953  *
 954  * Parameter newsize: New size of vector.
 955  * Throws std::bad_alloc: Not enough memory.
 956  */
 957         void resize(size_t newsize) throw(std::bad_alloc);
 958 /**
 959  * Walk the indexes of sync subframes.
 960  *
 961  * - If frame is in range and there is at least one more sync subframe after it, the index of first sync subframe
 962  *   after given frame.
 963  * - If frame is in range, but there are no more sync subframes after it, the length of vector is returned.
 964  * - If frame is out of range, the given frame is returned.
 965  *
 966  * Parameter frame: The frame number to start search from.
 967  * Returns: Index of next sync frame.
 968  */
 969         size_t walk_sync(size_t frame) throw()
 970         {
 971                 return walk_helper(frame, true);
 972         }
 973 /**
 974  * Get number of subframes in frame. The given subframe is assumed to be sync subframe.
 975  *
 976  * - The return value is the same as (walk_sync(frame) - frame).
 977  *
 978  * Parameter frame: The frame number to start search from.
 979  * Returns: Number of subframes in this frame.
 980  */
 981         size_t subframe_count(size_t frame) throw()
 982         {
 983                 return walk_helper(frame, false);
 984         }
 985 /**
 986  * Count number of subframes in vector with sync flag set.
 987  *
 988  * Returns: The number of frames.
 989  */
 990         size_t count_frames() throw();
 991 /**
 992  * Return blank controller frame with correct type and dedicated memory.
 993  *
 994  * Parameter sync: If set, the frame will have sync flag set, otherwise it will have sync flag clear.
 995  * Returns: Blank frame.
 996  */
 997         controller_frame blank_frame(bool sync)
 998         {
 999                 controller_frame c(types[0], types[1]);
1000                 c.sync(sync);
1001                 return c;
1002         }
1003 private:
1004         class page
1005         {
1006         public:
1007                 page() { memset(content, 0, CONTROLLER_PAGE_SIZE); }
1008                 unsigned char content[CONTROLLER_PAGE_SIZE];
1009         };
1010         size_t frames_per_page;
1011         size_t frame_size;
1012         size_t frames;
1013         porttype_t types[MAX_PORTS];
1014         size_t cache_page_num;
1015         page* cache_page;
1016         std::map<size_t, page> pages;
1017         size_t walk_helper(size_t frame, bool sflag) throw();
1018         void clear_cache()
1019         {
1020                 cache_page_num = 0;
1021                 cache_page_num--;
1022                 cache_page = NULL;
1023         }
1024 };
1025
1026 /**
1027  * Controllers state.
1028  */
1029 class controller_state
1030 {
1031 public:
1032 /**
1033  * Constructor.
1034  */
1035         controller_state() throw();
1036 /**
1037  * Convert lcid (Logical Controller ID) into pcid (Physical Controler ID).
1038  *
1039  * Parameter lcid: The logical controller ID.
1040  * Return: The physical controller ID, or -1 if no such controller exists.
1041  */
1042         int lcid_to_pcid(unsigned lcid) throw();
1043 /**
1044  * Convert lcid (Logical Controller ID) into type string.
1045  *
1046  * Parameter lcid: The logical controller ID.
1047  * Return: The type of controller
1048  */
1049         std::string lcid_to_typestring(unsigned lcid) throw(std::bad_alloc);
1050 /**
1051  * Convert acid (Analog Controller ID) into pcid.
1052  *
1053  * Parameter acid: The analog controller ID.
1054  * Return: The physical controller ID, or -1 if no such controller exists.
1055  */
1056         int acid_to_pcid(unsigned acid) throw();
1057 /**
1058  * Is given acid a mouse?
1059  *
1060  * Parameter acid: The analog controller ID.
1061  * Returns: True if given acid is mouse, false otherwise.
1062  */
1063         bool acid_is_mouse(unsigned acid) throw();
1064 /**
1065  * Look up device type type of given pcid.
1066  *
1067  * Parameter pcid: The physical controller id.
1068  * Returns: The type of device.
1069  */
1070         devicetype_t pcid_to_type(unsigned pcid) throw();
1071 /**
1072  * Set type of port.
1073  *
1074  * Parameter port: The port to set.
1075  * Parameter ptype: The new type for port.
1076  * Parameter set_core: If true, set the core port type too, otherwise don't do that.
1077  * Throws std::runtime_error: Illegal port type.
1078  */
1079         void set_port(unsigned port, porttype_t ptype, bool set_core) throw(std::runtime_error);
1080 /**
1081  * Get status of current controls (with autohold/autofire factored in).
1082  *
1083  * Parameter framenum: Number of current frame (for evaluating autofire).
1084  * Returns: The current controls.
1085  */
1086         controller_frame get(uint64_t framenum) throw();
1087 /**
1088  * Commit given controls (autohold/autofire is factored in).
1089  *
1090  * Parameter framenum: Number of current frame (for evaluating autofire).
1091  * Returns: The committed controls.
1092  */
1093         controller_frame commit(uint64_t framenum) throw();
1094 /**
1095  * Commit given controls (autohold/autofire is ignored).
1096  *
1097  * Parameter controls: The controls to commit
1098  * Returns: The committed controls.
1099  */
1100         controller_frame commit(controller_frame controls) throw();
1101 /**
1102  * Get status of committed controls.
1103  * Returns: The committed controls.
1104  */
1105         controller_frame get_committed() throw();
1106 /**
1107  * Get blank frame.
1108  */
1109         controller_frame get_blank() throw();
1110 /**
1111  * Send analog input to given acid.
1112  *
1113  * Parameter acid: The acid to send input to.
1114  * Parameter x: The x coordinate to send.
1115  * Parameter y: The x coordinate to send.
1116  */
1117         void analog(unsigned acid, int x, int y) throw();
1118 /**
1119  * Manipulate the reset flag.
1120  *
1121  * Parameter delay: Delay for reset (-1 for no reset)
1122  */
1123         void reset(int32_t delay) throw();
1124 /**
1125  * Manipulate autohold.
1126  *
1127  * Parameter pcid: The physical controller ID to manipulate.
1128  * Parameter pbid: The physical button ID to manipulate.
1129  * Parameter newstate: The new state for autohold.
1130  */
1131         void autohold(unsigned pcid, unsigned pbid, bool newstate) throw();
1132 /**
1133  * Query autohold.
1134  *
1135  * Parameter pcid: The physical controller ID to query.
1136  * Parameter pbid: The physical button ID to query.
1137  * Returns: The state of autohold.
1138  */
1139         bool autohold(unsigned pcid, unsigned pbid) throw();
1140 /**
1141  * Manipulate button.
1142  *
1143  * Parameter pcid: The physical controller ID to manipulate.
1144  * Parameter pbid: The physical button ID to manipulate.
1145  * Parameter newstate: The new state for button.
1146  */
1147         void button(unsigned pcid, unsigned pbid, bool newstate) throw();
1148 /**
1149  * Query button.
1150  *
1151  * Parameter pcid: The physical controller ID to query.
1152  * Parameter pbid: The physical button ID to query.
1153  * Returns: The state of button.
1154  */
1155         bool button(unsigned pcid, unsigned pbid) throw();
1156 /**
1157  * Set autofire pattern.
1158  *
1159  * Parameter pattern: The new pattern.
1160  * Throws std::bad_alloc: Not enough memory.
1161  */
1162         void autofire(std::vector<controller_frame> pattern) throw(std::bad_alloc);
1163 /**
1164  * Get physical button ID for physical controller ID and logical button ID.
1165  *
1166  * Parameter pcid: Physical controller id.
1167  * Parameter lbid: Logical button id.
1168  * Returns: The physical button id, or -1 if no such button.
1169  */
1170         int button_id(unsigned pcid, unsigned lbid) throw();
1171 /**
1172  * TODO: Document.
1173  */
1174         bool is_analog(unsigned pcid) throw();
1175 /**
1176  * TODO: Document.
1177  */
1178         bool is_mouse(unsigned pcid) throw();
1179 private:
1180         const porttype_info* porttypeinfo[MAX_PORTS];
1181         porttype_t porttypes[MAX_PORTS];
1182         int analog_indices[MAX_ANALOG];
1183         bool analog_mouse[MAX_ANALOG];
1184         controller_frame _input;
1185         controller_frame _autohold;
1186         controller_frame _committed;
1187         std::vector<controller_frame> _autofire;
1188 };
1189
1190 #endif