1 /* 2 * Copyright 2002, Marcus Overhagen. All Rights Reserved. 3 * Copyright 2009, Axel Dörfler, axeld@pinc-software.de. 4 * Distributed under the terms of the MIT License. 5 */ 6 #ifndef _SERVER_INTERFACE_H_ 7 #define _SERVER_INTERFACE_H_ 8 9 10 #include <string.h> 11 12 #include <Buffer.h> 13 #include <Entry.h> 14 #include <MediaAddOn.h> 15 #include <MediaDefs.h> 16 #include <MediaFormats.h> 17 #include <MediaNode.h> 18 #include <Messenger.h> 19 20 21 // BMessage based server communication 22 enum { 23 // BMediaRoster notification service 24 MEDIA_SERVER_REQUEST_NOTIFICATIONS = 1000, 25 MEDIA_SERVER_CANCEL_NOTIFICATIONS, 26 MEDIA_SERVER_SEND_NOTIFICATIONS, 27 28 // add_system_beep_event() 29 MEDIA_SERVER_ADD_SYSTEM_BEEP_EVENT, 30 31 // sent by the rescan thread 32 MEDIA_SERVER_RESCAN_COMPLETED, 33 // sent to rosters when rescan is completed 34 MEDIA_SERVER_ALIVE, 35 36 // media add-on server 37 MEDIA_ADD_ON_SERVER_PLAY_MEDIA = '_TRU' 38 }; 39 40 enum { 41 // local media services status notification service 42 MEDIA_ROSTER_REQUEST_NOTIFICATIONS = 2000, 43 MEDIA_ROSTER_CANCEL_NOTIFICATIONS, 44 45 // used to sync with media services startup 46 MEDIA_ROSTER_REGISTER_SYNC 47 }; 48 49 // Raw port based communication 50 enum { 51 GENERAL_PURPOSE_WAKEUP = 0, // when no action but wait termination needed 52 53 ADD_ON_SERVER_RESCAN_ADD_ON_FLAVORS = 0x50, 54 ADD_ON_SERVER_RESCAN_FINISHED_NOTIFY, 55 ADD_ON_SERVER_INSTANTIATE_DORMANT_NODE, 56 57 SERVER_MESSAGE_START = 0x100, 58 SERVER_REGISTER_APP, 59 SERVER_UNREGISTER_APP, 60 SERVER_GET_NODE, 61 SERVER_SET_NODE, 62 SERVER_PUBLISH_INPUTS, 63 SERVER_PUBLISH_OUTPUTS, 64 SERVER_NODE_ID_FOR, 65 SERVER_GET_LIVE_NODE_INFO, 66 SERVER_GET_LIVE_NODES, 67 SERVER_GET_NODE_FOR, 68 SERVER_RELEASE_NODE, 69 SERVER_RELEASE_NODE_ALL, 70 SERVER_REGISTER_NODE, 71 SERVER_UNREGISTER_NODE, 72 SERVER_GET_DORMANT_NODE_FOR, 73 SERVER_GET_INSTANCES_FOR, 74 SERVER_GET_SHARED_BUFFER_AREA, 75 SERVER_REGISTER_BUFFER, 76 SERVER_UNREGISTER_BUFFER, 77 SERVER_RESCAN_DEFAULTS, 78 SERVER_SET_NODE_CREATOR, 79 SERVER_CHANGE_FLAVOR_INSTANCES_COUNT, 80 SERVER_GET_MEDIA_FILE_TYPES, 81 SERVER_GET_MEDIA_FILE_ITEMS, 82 SERVER_GET_REF_FOR, 83 SERVER_SET_REF_FOR, 84 SERVER_INVALIDATE_MEDIA_ITEM, 85 SERVER_REMOVE_MEDIA_ITEM, 86 SERVER_GET_ITEM_AUDIO_GAIN, 87 SERVER_SET_ITEM_AUDIO_GAIN, 88 SERVER_GET_FORMAT_FOR_DESCRIPTION, 89 SERVER_GET_DESCRIPTION_FOR_FORMAT, 90 SERVER_REGISTER_ADD_ON, 91 SERVER_UNREGISTER_ADD_ON, 92 SERVER_GET_ADD_ON_REF, 93 SERVER_REGISTER_DORMANT_NODE, 94 SERVER_GET_DORMANT_NODES, 95 SERVER_GET_DORMANT_FLAVOR_INFO, 96 SERVER_SET_NODE_TIMESOURCE, 97 SERVER_MESSAGE_END, 98 99 NODE_MESSAGE_START = 0x200, 100 NODE_START, 101 NODE_STOP, 102 NODE_SEEK, 103 NODE_SET_RUN_MODE, 104 NODE_TIME_WARP, 105 NODE_PREROLL, 106 NODE_ROLL, 107 NODE_SYNC_TO, 108 NODE_SET_TIMESOURCE, 109 NODE_GET_TIMESOURCE, 110 NODE_GET_ATTRIBUTES_FOR, 111 NODE_REQUEST_COMPLETED, 112 NODE_FINAL_RELEASE, 113 NODE_MESSAGE_END, 114 115 CONSUMER_MESSAGE_START = 0x300, 116 CONSUMER_GET_NEXT_INPUT, 117 CONSUMER_DISPOSE_INPUT_COOKIE, 118 CONSUMER_ACCEPT_FORMAT, 119 CONSUMER_CONNECTED, 120 CONSUMER_DISCONNECTED, 121 CONSUMER_BUFFER_RECEIVED, 122 CONSUMER_PRODUCER_DATA_STATUS, 123 CONSUMER_GET_LATENCY_FOR, 124 CONSUMER_FORMAT_CHANGED, 125 CONSUMER_SEEK_TAG_REQUESTED, 126 CONSUMER_MESSAGE_END, 127 128 PRODUCER_MESSAGE_START = 0x400, 129 PRODUCER_GET_NEXT_OUTPUT, 130 PRODUCER_DISPOSE_OUTPUT_COOKIE, 131 PRODUCER_FORMAT_PROPOSAL, 132 PRODUCER_PREPARE_TO_CONNECT, 133 PRODUCER_CONNECT, 134 PRODUCER_DISCONNECT, 135 PRODUCER_LATE_NOTICE_RECEIVED, 136 PRODUCER_LATENCY_CHANGED, 137 PRODUCER_ADDITIONAL_BUFFER_REQUESTED, 138 PRODUCER_VIDEO_CLIPPING_CHANGED, 139 PRODUCER_FORMAT_CHANGE_REQUESTED, 140 PRODUCER_SET_BUFFER_GROUP, 141 PRODUCER_GET_LATENCY, 142 PRODUCER_GET_INITIAL_LATENCY, 143 PRODUCER_FORMAT_SUGGESTION_REQUESTED, 144 PRODUCER_SET_PLAY_RATE, 145 PRODUCER_ENABLE_OUTPUT, 146 PRODUCER_SET_RUN_MODE_DELAY, 147 PRODUCER_MESSAGE_END, 148 149 FILEINTERFACE_MESSAGE_START = 0x500, 150 FILEINTERFACE_SET_REF, 151 FILEINTERFACE_GET_REF, 152 FILEINTERFACE_SNIFF_REF, 153 FILEINTERFACE_GET_FORMATS, 154 FILEINTERFACE_MESSAGE_END, 155 156 CONTROLLABLE_MESSAGE_START = 0x600, 157 CONTROLLABLE_GET_PARAMETER_WEB, 158 CONTROLLABLE_GET_PARAMETER_DATA, 159 CONTROLLABLE_SET_PARAMETER_DATA, 160 CONTROLLABLE_START_CONTROL_PANEL, 161 CONTROLLABLE_MESSAGE_END, 162 163 TIMESOURCE_MESSAGE_START = 0x700, 164 TIMESOURCE_OP, // datablock is a struct time_source_op_info 165 TIMESOURCE_ADD_SLAVE_NODE, 166 TIMESOURCE_REMOVE_SLAVE_NODE, 167 TIMESOURCE_GET_START_LATENCY, 168 TIMESOURCE_MESSAGE_END, 169 }; 170 171 172 namespace BPrivate { 173 namespace media { 174 175 176 struct reply_data; 177 struct request_data; 178 struct command_data; 179 180 181 // The base struct used for all raw requests 182 struct request_data { 183 port_id reply_port; 184 185 request_data(); 186 ~request_data(); 187 188 status_t SendReply(status_t result, reply_data* reply, 189 size_t replySize) const; 190 }; 191 192 // The base struct used for all raw replys 193 struct reply_data { 194 status_t result; 195 }; 196 197 // The base struct used for all raw commands (asynchronous, no answer) 198 struct command_data { 199 // yes, it's empty ;) 200 201 #if __GNUC__ >= 4 202 int32 _padding; 203 // GCC 2 and GCC 4 treat empty structures differently 204 #endif 205 }; 206 207 // The base struct used for all requests using an area 208 struct area_request_data : request_data { 209 area_id area; 210 }; 211 212 // The base struct used for all requests requesting an area 213 struct request_area_data : request_data { 214 team_id team; 215 }; 216 217 // The base struct used for all replies using an area 218 struct area_reply_data : reply_data { 219 area_id area; 220 void* address; 221 }; 222 223 224 /* We can't send an entry_ref through a port to another team, 225 * but we can assign it to an xfer_entry_ref and send this one, 226 * when we receive it we can assign it to a normal entry_ref 227 */ 228 struct xfer_entry_ref { 229 public: 230 xfer_entry_ref() 231 { 232 device = -1; 233 directory = -1; 234 name[0] = 0; 235 } 236 237 operator entry_ref() const 238 { 239 entry_ref ref(device, directory, name); 240 return ref; 241 } 242 243 xfer_entry_ref& operator=(const entry_ref& ref) 244 { 245 device = ref.device; 246 directory = ref.directory; 247 if (ref.name) 248 strcpy(name, ref.name); 249 else 250 name[0] = 0; 251 252 return *this; 253 } 254 255 private: 256 dev_t device; 257 ino_t directory; 258 char name[B_FILE_NAME_LENGTH]; 259 }; 260 261 262 } // namespace media 263 } // namespace BPrivate 264 265 using namespace BPrivate::media; 266 267 // used by SERVER_GET_NODE and SERVER_SET_NODE 268 enum node_type { 269 VIDEO_INPUT, 270 AUDIO_INPUT, 271 VIDEO_OUTPUT, 272 AUDIO_MIXER, 273 AUDIO_OUTPUT, 274 AUDIO_OUTPUT_EX, 275 TIME_SOURCE, 276 SYSTEM_TIME_SOURCE 277 }; 278 279 // used by SERVER_PUBLISH_INPUTS and SERVER_PUBLISH_OUTPUTS 280 enum { 281 MAX_OUTPUTS = 8, 282 MAX_INPUTS = 8, 283 }; 284 285 // used by SERVER_GET_LIVE_NODES 286 enum { 287 MAX_LIVE_INFO = 16, 288 }; 289 290 // used by SERVER_GET_INSTANCES_FOR 291 enum { 292 MAX_NODE_ID = 4000, 293 }; 294 295 // used by SERVER_GET_READERS 296 enum { 297 MAX_READERS = 40, 298 }; 299 300 301 // #pragma mark - media add-on server commands 302 303 304 struct add_on_server_instantiate_dormant_node_request : request_data { 305 media_addon_id add_on_id; 306 int32 flavor_id; 307 team_id creator_team; 308 }; 309 310 struct add_on_server_instantiate_dormant_node_reply : reply_data { 311 media_node node; 312 }; 313 314 struct add_on_server_rescan_flavors_command : command_data { 315 media_addon_id add_on_id; 316 }; 317 318 struct add_on_server_rescan_finished_notify_command : command_data { 319 }; 320 321 322 // #pragma mark - media server commands 323 324 325 struct server_set_node_request : request_data { 326 node_type type; 327 bool use_node; 328 media_node node; 329 bool use_dni; 330 dormant_node_info dni; 331 bool use_input; 332 media_input input; 333 }; 334 335 struct server_set_node_reply : reply_data { 336 }; 337 338 struct server_get_node_request : request_data { 339 node_type type; 340 team_id team; 341 }; 342 343 struct server_get_node_reply : public reply_data { 344 media_node node; 345 346 // for AUDIO_OUTPUT_EX 347 char input_name[B_MEDIA_NAME_LENGTH]; 348 int32 input_id; 349 }; 350 351 struct server_publish_inputs_request : request_data { 352 media_node node; 353 int32 count; 354 area_id area; // if count > MAX_INPUTS, inputs are in the area 355 // area is created in the library, and also deleted 356 // in the library after the reply has been received 357 media_input inputs[MAX_INPUTS]; 358 }; 359 360 struct server_publish_inputs_reply : reply_data { 361 }; 362 363 struct server_publish_outputs_request : area_request_data { 364 media_node node; 365 int32 count; 366 // if count > MAX_OUTPUTS, outputs are in the area 367 // area is created in the library, and also deleted 368 // in the library after the reply has been received 369 media_output outputs[MAX_OUTPUTS]; 370 }; 371 372 struct server_publish_outputs_reply : reply_data { 373 }; 374 375 struct server_register_app_request : request_data { 376 team_id team; 377 BMessenger messenger; 378 }; 379 380 struct server_register_app_reply : reply_data { 381 }; 382 383 struct server_unregister_app_request : request_data { 384 team_id team; 385 }; 386 387 struct server_unregister_app_reply : reply_data { 388 }; 389 390 struct server_set_node_creator_request : request_data { 391 media_node_id node; 392 team_id creator; 393 }; 394 395 struct server_set_node_creator_reply : reply_data { 396 }; 397 398 struct server_change_flavor_instances_count_request : request_data { 399 media_addon_id add_on_id; 400 int32 flavor_id; 401 int32 delta; // must be +1 or -1 402 team_id team; 403 }; 404 405 struct server_change_flavor_instances_count_reply : reply_data { 406 }; 407 408 struct server_register_node_request : request_data { 409 media_addon_id add_on_id; 410 int32 flavor_id; 411 media_node_id timesource_id; 412 char name[B_MEDIA_NAME_LENGTH]; 413 uint64 kinds; 414 port_id port; 415 team_id team; 416 }; 417 418 struct server_register_node_reply : reply_data { 419 media_node_id node_id; 420 }; 421 422 struct server_unregister_node_request : request_data { 423 media_node_id node_id; 424 team_id team; 425 }; 426 427 struct server_unregister_node_reply : reply_data { 428 media_addon_id add_on_id; 429 int32 flavor_id; 430 }; 431 432 struct server_get_live_node_info_request : request_data { 433 media_node node; 434 }; 435 436 struct server_get_live_node_info_reply : reply_data { 437 live_node_info live_info; 438 }; 439 440 struct server_get_live_nodes_request : request_area_data { 441 int32 max_count; 442 bool has_input; 443 bool has_output; 444 bool has_name; 445 media_format input_format; 446 media_format output_format; 447 char name[B_MEDIA_NAME_LENGTH + 1]; 448 // +1 for a trailing "*" 449 uint64 require_kinds; 450 }; 451 452 struct server_get_live_nodes_reply : area_reply_data { 453 int32 count; 454 // if count > MAX_LIVE_INFO, live_node_infos are in the area 455 // area is created in the server, but deleted in the library 456 live_node_info live_info[MAX_LIVE_INFO]; 457 }; 458 459 struct server_node_id_for_request : request_data { 460 port_id port; 461 }; 462 463 struct server_node_id_for_reply : reply_data { 464 media_node_id node_id; 465 }; 466 467 struct server_get_node_for_request : request_data { 468 media_node_id node_id; 469 team_id team; 470 }; 471 472 struct server_get_node_for_reply : reply_data { 473 media_node clone; 474 }; 475 476 struct server_release_node_request : request_data { 477 media_node node; 478 team_id team; 479 }; 480 481 struct server_release_node_reply : reply_data { 482 }; 483 484 struct server_get_dormant_node_for_request : request_data { 485 media_node node; 486 }; 487 488 struct server_get_dormant_node_for_reply : reply_data { 489 dormant_node_info node_info; 490 }; 491 492 struct server_get_instances_for_request : request_data { 493 media_addon_id add_on_id; 494 int32 flavor_id; 495 int32 max_count; 496 }; 497 498 struct server_get_instances_for_reply : reply_data { 499 int32 count; 500 media_node_id node_id[MAX_NODE_ID]; 501 // no area here, MAX_NODE_ID is really large 502 }; 503 504 struct server_rescan_defaults_command : command_data { 505 }; 506 507 struct server_register_add_on_request : request_data { 508 xfer_entry_ref ref; 509 }; 510 511 struct server_register_add_on_reply : reply_data { 512 media_addon_id add_on_id; 513 }; 514 515 struct server_unregister_add_on_command : command_data { 516 media_addon_id add_on_id; 517 }; 518 519 struct server_get_add_on_ref_request : request_data { 520 media_addon_id add_on_id; 521 }; 522 523 struct server_get_add_on_ref_reply : reply_data { 524 xfer_entry_ref ref; 525 }; 526 527 struct server_get_shared_buffer_area_request : request_data { 528 }; 529 530 struct server_get_shared_buffer_area_reply : area_reply_data { 531 }; 532 533 struct server_register_buffer_request : request_data { 534 team_id team; 535 buffer_clone_info info; 536 // either info.buffer is != 0, or the area, size, offset is used 537 }; 538 539 struct server_register_buffer_reply : reply_data { 540 buffer_clone_info info; 541 }; 542 543 struct server_unregister_buffer_command : command_data { 544 team_id team; 545 media_buffer_id buffer_id; 546 }; 547 548 struct server_get_media_types_request : request_area_data { 549 }; 550 551 struct server_get_media_types_reply : area_reply_data { 552 int32 count; 553 }; 554 555 struct server_get_media_items_request : request_area_data { 556 char type[B_MEDIA_NAME_LENGTH]; 557 }; 558 559 struct server_get_media_items_reply : area_reply_data { 560 int32 count; 561 }; 562 563 struct server_get_ref_for_request : request_data { 564 char type[B_MEDIA_NAME_LENGTH]; 565 char item[B_MEDIA_NAME_LENGTH]; 566 }; 567 568 struct server_get_ref_for_reply : reply_data { 569 xfer_entry_ref ref; 570 }; 571 572 struct server_set_ref_for_request : request_data { 573 char type[B_MEDIA_NAME_LENGTH]; 574 char item[B_MEDIA_NAME_LENGTH]; 575 xfer_entry_ref ref; 576 }; 577 578 struct server_set_ref_for_reply : reply_data { 579 }; 580 581 struct server_invalidate_item_request : request_data { 582 char type[B_MEDIA_NAME_LENGTH]; 583 char item[B_MEDIA_NAME_LENGTH]; 584 }; 585 586 struct server_invalidate_item_reply : reply_data { 587 }; 588 589 struct server_remove_media_item_request : request_data { 590 char type[B_MEDIA_NAME_LENGTH]; 591 char item[B_MEDIA_NAME_LENGTH]; 592 }; 593 594 struct server_remove_media_item_reply : reply_data { 595 }; 596 597 struct server_get_item_audio_gain_request : request_data { 598 char type[B_MEDIA_NAME_LENGTH]; 599 char item[B_MEDIA_NAME_LENGTH]; 600 }; 601 602 struct server_get_item_audio_gain_reply : reply_data { 603 float gain; 604 }; 605 606 struct server_set_item_audio_gain_request : request_data { 607 char type[B_MEDIA_NAME_LENGTH]; 608 char item[B_MEDIA_NAME_LENGTH]; 609 float gain; 610 }; 611 612 struct server_set_item_audio_gain_reply : reply_data { 613 }; 614 615 616 struct server_get_dormant_flavor_info_request : request_data { 617 media_addon_id add_on_id; 618 int32 flavor_id; 619 }; 620 621 struct server_get_dormant_flavor_info_reply : reply_data { 622 type_code type; // the flatten type_code 623 size_t flattened_size; 624 char flattened_data[1]; 625 // a flattened dormant_flavor_info, flattened_size large 626 }; 627 628 struct server_get_dormant_nodes_request : request_data { 629 int32 max_count; 630 bool has_input; 631 media_format input_format; 632 bool has_output; 633 media_format output_format; 634 bool has_name; 635 char name[B_MEDIA_NAME_LENGTH + 1]; // 1 for a trailing "*" 636 uint64 require_kinds; 637 uint64 deny_kinds; 638 }; 639 640 struct server_get_dormant_nodes_reply : reply_data { 641 int32 count; 642 // if count > 0, a second reply containing count dormant_node_infos 643 // is send 644 }; 645 646 struct server_register_dormant_node_command : command_data { 647 media_addon_id purge_id; 648 // if > 0, server must first remove all dormant_flavor_infos 649 // belonging to that id 650 type_code type; // the flatten type_code 651 size_t flattened_size; 652 char flattened_data[1]; 653 // a flattened dormant_flavor_info, flattened_size large 654 }; 655 656 struct server_set_node_timesource_request : request_data { 657 media_node_id node_id; 658 media_node_id timesource_id; 659 }; 660 661 struct server_set_node_timesource_reply : reply_data { 662 }; 663 664 665 // #pragma mark - buffer producer commands 666 667 668 struct producer_format_proposal_request : public request_data { 669 media_source output; 670 media_format format; 671 }; 672 673 struct producer_format_proposal_reply : reply_data { 674 media_format format; 675 }; 676 677 struct producer_prepare_to_connect_request : request_data { 678 media_source source; 679 media_destination destination; 680 media_format format; 681 char name[B_MEDIA_NAME_LENGTH]; 682 }; 683 684 struct producer_prepare_to_connect_reply : reply_data { 685 media_format format; 686 media_source out_source; 687 char name[B_MEDIA_NAME_LENGTH]; 688 }; 689 690 struct producer_connect_request : request_data { 691 status_t error; 692 media_source source; 693 media_destination destination; 694 media_format format; 695 char name[B_MEDIA_NAME_LENGTH]; 696 }; 697 698 struct producer_connect_reply : reply_data { 699 char name[B_MEDIA_NAME_LENGTH]; 700 }; 701 702 struct producer_disconnect_request : request_data { 703 media_source source; 704 media_destination destination; 705 }; 706 707 struct producer_disconnect_reply : reply_data { 708 }; 709 710 struct producer_format_suggestion_requested_request : request_data { 711 media_type type; 712 int32 quality; 713 }; 714 715 struct producer_format_suggestion_requested_reply : reply_data { 716 media_format format; 717 }; 718 719 struct producer_set_play_rate_request : request_data { 720 int32 numer; 721 int32 denom; 722 }; 723 724 struct producer_set_play_rate_reply : reply_data { 725 }; 726 727 struct producer_get_initial_latency_request : request_data { 728 }; 729 730 struct producer_get_initial_latency_reply : reply_data { 731 bigtime_t initial_latency; 732 uint32 flags; 733 }; 734 735 struct producer_get_latency_request : request_data { 736 }; 737 738 struct producer_get_latency_reply : reply_data { 739 bigtime_t latency; 740 }; 741 742 struct producer_set_buffer_group_command : command_data { 743 media_source source; 744 media_destination destination; 745 void* user_data; 746 int32 change_tag; 747 int32 buffer_count; 748 media_buffer_id buffers[1]; 749 }; 750 751 struct producer_format_change_requested_command : command_data { 752 media_source source; 753 media_destination destination; 754 media_format format; 755 void* user_data; 756 int32 change_tag; 757 }; 758 759 struct producer_video_clipping_changed_command : command_data { 760 media_source source; 761 media_destination destination; 762 media_video_display_info display; 763 void* user_data; 764 int32 change_tag; 765 int32 short_count; 766 int16 shorts[1]; 767 }; 768 769 struct producer_additional_buffer_requested_command : command_data { 770 media_source source; 771 media_buffer_id prev_buffer; 772 bigtime_t prev_time; 773 bool has_seek_tag; 774 media_seek_tag prev_tag; 775 }; 776 777 struct producer_latency_changed_command : command_data { 778 media_source source; 779 media_destination destination; 780 bigtime_t latency; 781 uint32 flags; 782 }; 783 784 struct producer_enable_output_command : command_data { 785 media_source source; 786 media_destination destination; 787 bool enabled; 788 void* user_data; 789 int32 change_tag; 790 }; 791 792 struct producer_late_notice_received_command : command_data { 793 media_source source; 794 bigtime_t how_much; 795 bigtime_t performance_time; 796 }; 797 798 struct producer_set_run_mode_delay_command : command_data { 799 BMediaNode::run_mode mode; 800 bigtime_t delay; 801 }; 802 803 struct producer_get_next_output_request : request_data { 804 int32 cookie; 805 }; 806 807 struct producer_get_next_output_reply : reply_data 808 { 809 int32 cookie; 810 media_output output; 811 }; 812 813 struct producer_dispose_output_cookie_request : request_data 814 { 815 int32 cookie; 816 }; 817 818 struct producer_dispose_output_cookie_reply : reply_data { 819 }; 820 821 822 // #pragma mark - buffer consumer commands 823 824 825 struct consumer_accept_format_request : request_data { 826 media_destination dest; 827 media_format format; 828 }; 829 830 struct consumer_accept_format_reply : reply_data { 831 media_format format; 832 }; 833 834 struct consumer_connected_request : request_data { 835 media_input input; 836 }; 837 838 struct consumer_connected_reply : reply_data { 839 media_input input; 840 }; 841 842 struct consumer_get_next_input_request : request_data { 843 int32 cookie; 844 }; 845 846 struct consumer_get_next_input_reply : reply_data { 847 int32 cookie; 848 media_input input; 849 }; 850 851 struct consumer_dispose_input_cookie_request : request_data { 852 int32 cookie; 853 }; 854 855 struct consumer_dispose_input_cookie_reply : reply_data { 856 }; 857 858 struct consumer_disconnected_request : request_data { 859 media_source source; 860 media_destination destination; 861 }; 862 863 struct consumer_disconnected_reply : reply_data { 864 }; 865 866 struct consumer_buffer_received_command : command_data { 867 media_buffer_id buffer; 868 media_header header; 869 }; 870 871 struct consumer_producer_data_status_command : command_data { 872 media_destination for_whom; 873 int32 status; 874 bigtime_t at_performance_time; 875 }; 876 877 struct consumer_get_latency_for_request : request_data { 878 media_destination for_whom; 879 }; 880 881 struct consumer_get_latency_for_reply : reply_data { 882 bigtime_t latency; 883 media_node_id timesource; 884 }; 885 886 struct consumer_format_changed_request : request_data { 887 media_source producer; 888 media_destination consumer; 889 int32 change_tag; 890 media_format format; 891 }; 892 893 struct consumer_format_changed_reply : reply_data { 894 }; 895 896 struct consumer_seek_tag_requested_request : request_data { 897 media_destination destination; 898 bigtime_t target_time; 899 uint32 flags; 900 }; 901 902 struct consumer_seek_tag_requested_reply : reply_data { 903 media_seek_tag seek_tag; 904 bigtime_t tagged_time; 905 uint32 flags; 906 }; 907 908 909 // #pragma mark - node commands 910 911 912 struct node_request_completed_command : command_data { 913 media_request_info info; 914 }; 915 916 struct node_start_command : command_data { 917 bigtime_t performance_time; 918 }; 919 920 struct node_stop_command : command_data { 921 bigtime_t performance_time; 922 bool immediate; 923 }; 924 925 struct node_seek_command : command_data { 926 bigtime_t media_time; 927 bigtime_t performance_time; 928 }; 929 930 struct node_roll_command : command_data { 931 bigtime_t start_performance_time; 932 bigtime_t stop_performance_time; 933 bigtime_t seek_media_time; 934 }; 935 936 struct node_sync_to_request : request_data { 937 bigtime_t performance_time; 938 port_id port; 939 }; 940 941 struct node_sync_to_reply : reply_data { 942 }; 943 944 struct node_set_run_mode_command : command_data { 945 BMediaNode::run_mode mode; 946 }; 947 948 struct node_time_warp_command : command_data { 949 bigtime_t at_real_time; 950 bigtime_t to_performance_time; 951 }; 952 953 struct node_set_timesource_command : command_data { 954 media_node_id timesource_id; 955 }; 956 957 struct node_get_timesource_request : request_data { 958 }; 959 960 struct node_get_timesource_reply : reply_data { 961 media_node_id timesource_id; 962 }; 963 964 struct node_get_attributes_for_request : request_data { 965 size_t count; 966 area_id area; 967 }; 968 969 struct node_get_attributes_for_reply : reply_data { 970 size_t filled_count; 971 }; 972 973 struct node_final_release_command : command_data { 974 }; 975 976 977 // #pragma mark - time source commands 978 979 980 struct timesource_add_slave_node_command : command_data { 981 media_node node; 982 }; 983 984 struct timesource_remove_slave_node_command : command_data { 985 media_node node; 986 }; 987 988 struct timesource_get_start_latency_request : request_data { 989 }; 990 991 struct timesource_get_start_latency_reply : reply_data { 992 bigtime_t start_latency; 993 }; 994 995 996 // #pragma mark - file interface commands 997 998 999 struct fileinterface_set_ref_request : request_data { 1000 dev_t device; 1001 ino_t directory; 1002 char name[B_FILE_NAME_LENGTH]; 1003 bigtime_t duration; 1004 bool create; 1005 }; 1006 1007 struct fileinterface_set_ref_reply : reply_data { 1008 bigtime_t duration; 1009 }; 1010 1011 struct fileinterface_get_ref_request : request_data { 1012 }; 1013 1014 struct fileinterface_get_ref_reply : reply_data { 1015 dev_t device; 1016 ino_t directory; 1017 char name[B_FILE_NAME_LENGTH]; 1018 char mimetype[B_MIME_TYPE_LENGTH]; 1019 }; 1020 1021 struct fileinterface_sniff_ref_request : request_data { 1022 dev_t device; 1023 ino_t directory; 1024 char name[B_FILE_NAME_LENGTH]; 1025 }; 1026 1027 struct fileinterface_sniff_ref_reply : reply_data { 1028 char mimetype[B_MIME_TYPE_LENGTH]; 1029 float capability; 1030 }; 1031 1032 struct fileinterface_get_formats_request : request_data { 1033 int32 num_formats; 1034 area_id data_area; 1035 }; 1036 1037 struct fileinterface_get_formats_reply : reply_data { 1038 int32 filled_slots; 1039 }; 1040 1041 // #pragma mark - controllable commands 1042 1043 1044 struct controllable_get_parameter_web_request : area_request_data { 1045 int32 max_size; 1046 }; 1047 1048 struct controllable_get_parameter_web_reply : reply_data { 1049 type_code code; 1050 int32 size; 1051 // = -1: parameter web data too large, 1052 // = 0: no p.w., > 0: flattened p.w. data 1053 }; 1054 1055 #define MAX_PARAMETER_DATA (B_MEDIA_MESSAGE_SIZE - 100) 1056 1057 struct controllable_get_parameter_data_request : area_request_data { 1058 int32 parameter_id; 1059 size_t request_size; 1060 }; 1061 1062 struct controllable_get_parameter_data_reply : reply_data { 1063 bigtime_t last_change; 1064 char raw_data[MAX_PARAMETER_DATA]; 1065 size_t size; 1066 }; 1067 1068 struct controllable_set_parameter_data_request : area_request_data { 1069 int32 parameter_id; 1070 bigtime_t when; 1071 size_t size; 1072 char raw_data[MAX_PARAMETER_DATA]; 1073 }; 1074 1075 struct controllable_set_parameter_data_reply : reply_data { 1076 }; 1077 1078 struct controllable_start_control_panel_request : request_data { 1079 media_node node; 1080 }; 1081 1082 struct controllable_start_control_panel_reply : reply_data { 1083 team_id team; 1084 }; 1085 1086 1087 #endif // _SERVER_INTERFACE_H_ 1088