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