1/* 2 * Copyright 2015 Dario Casalinuovo 3 * Copyright 2009-2012, Axel D��rfler, axeld@pinc-software.de. 4 * Copyright 2008 Maurice Kalinowski, haiku@kaldience.com 5 * 6 * All rights reserved. Distributed under the terms of the MIT License. 7 */ 8 9/* 10 * Copyright (c) 2002-2006 Marcus Overhagen <Marcus@Overhagen.de> 11 * 12 * Permission is hereby granted, free of charge, to any person obtaining 13 * a copy of this software and associated documentation files or portions 14 * thereof (the "Software"), to deal in the Software without restriction, 15 * including without limitation the rights to use, copy, modify, merge, 16 * publish, distribute, sublicense, and/or sell copies of the Software, 17 * and to permit persons to whom the Software is furnished to do so, subject 18 * to the following conditions: 19 * 20 * * Redistributions of source code must retain the above copyright notice, 21 * this list of conditions and the following disclaimer. 22 * 23 * * Redistributions in binary form must reproduce the above copyright notice 24 * in the binary, as well as this list of conditions and the following 25 * disclaimer in the documentation and/or other materials provided with 26 * the distribution. 27 * 28 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 29 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 30 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 31 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 32 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 33 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 34 * THE SOFTWARE. 35 */ 36 37 38/* to comply with the license above, do not remove the following line */ 39char __dont_remove_copyright_from_binary[] = "Copyright (c) 2002-2006 Marcus " 40 "Overhagen <Marcus@Overhagen.de>"; 41 42 43#include <MediaRoster.h> 44 45#include <Application.h> 46#include <Autolock.h> 47#include <BufferConsumer.h> 48#include <BufferProducer.h> 49#include <Locker.h> 50#include <Message.h> 51#include <Messenger.h> 52#include <MimeType.h> 53#include <OS.h> 54#include <ParameterWeb.h> 55#include <Roster.h> 56#include <StopWatch.h> 57#include <String.h> 58#include <TimeSource.h> 59 60#include <new> 61 62#include <AppMisc.h> 63#include <DataExchange.h> 64#include <MediaDebug.h> 65#include <DormantNodeManager.h> 66#include <MediaMisc.h> 67#include <MediaRosterEx.h> 68#include <Notifications.h> 69#include <ServerInterface.h> 70#include <SharedBufferList.h> 71#include <TList.h> 72 73#include "PortPool.h" 74#include "TimeSourceObjectManager.h" 75 76 77namespace BPrivate { 78namespace media { 79 80 81struct RosterNotification { 82 BMessenger messenger; 83 int32 what; 84}; 85 86 87struct SyncedMessage { 88 BMessage* message; 89}; 90 91 92struct LocalNode { 93 LocalNode(BMediaNode* local_node) 94 : 95 node(local_node) {} 96 97 LocalNode() 98 : 99 node(NULL) {} 100 101 bool operator==(const LocalNode& a) 102 { 103 if (a.node == this->node) 104 return true; 105 return false; 106 } 107 108 BMediaNode* node; 109}; 110 111 112static bool sServerIsUp = false; 113static List<RosterNotification> sNotificationList; 114static BLocker sInitLocker("BMediaRoster::Roster locker"); 115static List<LocalNode> sRegisteredNodes; 116 117 118// This class takes care of all static initialization and destruction of 119// libmedia objects. It guarantees that things are created and destroyed in 120// the correct order, as well as performing some "garbage collecting" by being 121// destructed automatically on application exit. 122class MediaRosterUndertaker { 123public: 124 MediaRosterUndertaker() 125 { 126 gPortPool = new PortPool(); 127 } 128 129 ~MediaRosterUndertaker() 130 { 131 BAutolock _(sInitLocker); 132 if (BMediaRoster::CurrentRoster() != NULL) { 133 134 // Detect any forgotten node 135 if (sRegisteredNodes.CountItems() > 0) { 136 for (int32 i = 0; i < sRegisteredNodes.CountItems(); i++) { 137 LocalNode* node = NULL; 138 sRegisteredNodes.Get(i, &node); 139 if (node != NULL) { 140 ERROR("BMediaRoster: Node with ID %" B_PRId32 141 " was not released correctly\n", node->node->ID()); 142 } 143 } 144 } 145 146 if (be_app != NULL) 147 be_app->UnregisterLooper(BMediaRoster::CurrentRoster()); 148 149 status_t err = B_ERROR; 150 thread_id roster = BMediaRoster::CurrentRoster()->Thread(); 151 152 BMediaRoster::CurrentRoster()->PostMessage(B_QUIT_REQUESTED); 153 154 wait_for_thread(roster, &err); 155 if (err != B_OK) 156 ERROR("BMediaRoster: wait_for_thread returned error"); 157 158 // Only now delete the port pool 159 delete gPortPool; 160 } 161 } 162}; 163 164 165static MediaRosterUndertaker sMediaRosterUndertaker; 166 167} // namespace media 168} // namespace BPrivate 169 170using namespace BPrivate::media; 171 172 173BMediaRosterEx::BMediaRosterEx(status_t* _error) 174 : 175 BMediaRoster(), 176 fLaunchNotification(false), 177 fAutoExit(false) 178{ 179 gDormantNodeManager = new DormantNodeManager(); 180 gTimeSourceObjectManager = new TimeSourceObjectManager(); 181 182 *_error = BuildConnections(); 183 184 InitRosterDataExchange(BMessenger(this, this)); 185 186 if (be_roster->StartWatching(BMessenger(this, this), 187 B_REQUEST_LAUNCHED | B_REQUEST_QUIT) != B_OK) { 188 *_error = B_ERROR; 189 } 190 sServerIsUp = BMediaRoster::IsRunning(); 191} 192 193 194void 195BMediaRosterEx::Quit() 196{ 197 if (be_roster->StopWatching(BMessenger(this, this)) != B_OK) 198 TRACE("Can't unregister roster notifications"); 199 200 if (sNotificationList.CountItems() != 0) 201 sNotificationList.MakeEmpty(); 202 203 BMediaRoster::Quit(); 204} 205 206 207status_t 208BMediaRosterEx::BuildConnections() 209{ 210 InitServerDataExchange(); 211 // register this application with the media server 212 server_register_app_request request; 213 server_register_app_reply reply; 214 request.team = BPrivate::current_team(); 215 request.messenger = BMessenger(NULL, this); 216 status_t status = QueryServer(SERVER_REGISTER_APP, &request, 217 sizeof(request), &reply, sizeof(reply)); 218 if (status != B_OK) 219 return B_MEDIA_SYSTEM_FAILURE; 220 221 return B_OK; 222} 223 224 225BMediaRosterEx::~BMediaRosterEx() 226{ 227 CALLED(); 228 229 delete gTimeSourceObjectManager; 230 delete gDormantNodeManager; 231 232 // unregister this application with the media server 233 server_unregister_app_request request; 234 server_unregister_app_reply reply; 235 request.team = BPrivate::current_team(); 236 QueryServer(SERVER_UNREGISTER_APP, &request, sizeof(request), &reply, 237 sizeof(reply)); 238 239 BPrivate::SharedBufferList::Invalidate(); 240} 241 242 243void 244BMediaRosterEx::RegisterLocalNode(BMediaNode* node) 245{ 246 sRegisteredNodes.Insert(LocalNode(node)); 247} 248 249 250void 251BMediaRosterEx::UnregisterLocalNode(BMediaNode* node) 252{ 253 int32 index = sRegisteredNodes.Find(LocalNode(node)); 254 if (index != -1) 255 sRegisteredNodes.Remove(index); 256} 257 258 259void 260BMediaRosterEx::EnableLaunchNotification(bool enable, bool autoExit) 261{ 262 // NOTE: in theory, we should personalize it depending on each 263 // request, but we are using it just in launch/shutdown_media_server, 264 // so we are enough safe to don't care about that. 265 fLaunchNotification = enable; 266 fAutoExit = autoExit; 267} 268 269 270status_t 271BMediaRosterEx::SaveNodeConfiguration(BMediaNode* node) 272{ 273 int32 flavorID; 274 BMediaAddOn* addon = node->AddOn(&flavorID); 275 if (addon == NULL) { 276 // NOTE: This node could have been created by an application, 277 // it does not mean there is an error. 278 // TODO: this check incorrectly triggers on BeOS R5 BT848 node 279 TRACE("BMediaRosterEx::SaveNodeConfiguration node %" B_PRId32 " not " 280 "instantiated from BMediaAddOn!\n", node->ID()); 281 return B_ERROR; 282 } 283 284 media_addon_id addonID = addon->AddonID(); 285 286 // TODO: fix this 287 printf("### BMediaRosterEx::SaveNodeConfiguration should save addon-id " 288 "%" B_PRId32 ", flavor-id %" B_PRId32 " config NOW!\n", addonID, 289 flavorID); 290 return B_OK; 291} 292 293 294status_t 295BMediaRosterEx::LoadNodeConfiguration(media_addon_id addonID, int32 flavorID, 296 BMessage *_msg) 297{ 298 // TODO: fix this 299 _msg->MakeEmpty(); // to be fully R5 compliant 300 printf("### BMediaRosterEx::LoadNodeConfiguration should load addon-id " 301 "%" B_PRId32 ", flavor-id %" B_PRId32 " config NOW!\n", addonID, 302 flavorID); 303 return B_OK; 304} 305 306 307status_t 308BMediaRosterEx::IncrementAddonFlavorInstancesCount(media_addon_id addonID, 309 int32 flavorID) 310{ 311 server_change_flavor_instances_count_request request; 312 server_change_flavor_instances_count_reply reply; 313 314 request.add_on_id = addonID; 315 request.flavor_id = flavorID; 316 request.delta = 1; 317 request.team = BPrivate::current_team(); 318 return QueryServer(SERVER_CHANGE_FLAVOR_INSTANCES_COUNT, &request, 319 sizeof(request), &reply, sizeof(reply)); 320} 321 322 323status_t 324BMediaRosterEx::DecrementAddonFlavorInstancesCount(media_addon_id addonID, 325 int32 flavorID) 326{ 327 server_change_flavor_instances_count_request request; 328 server_change_flavor_instances_count_reply reply; 329 330 request.add_on_id = addonID; 331 request.flavor_id = flavorID; 332 request.delta = -1; 333 request.team = BPrivate::current_team(); 334 return QueryServer(SERVER_CHANGE_FLAVOR_INSTANCES_COUNT, &request, 335 sizeof(request), &reply, sizeof(reply)); 336} 337 338 339status_t 340BMediaRosterEx::ReleaseNodeAll(const media_node& node) 341{ 342 CALLED(); 343 if (IS_INVALID_NODE(node)) 344 return B_MEDIA_BAD_NODE; 345 346 if (node.kind & NODE_KIND_NO_REFCOUNTING) 347 return B_OK; 348 349 server_release_node_request request; 350 server_release_node_reply reply; 351 status_t rv; 352 353 request.node = node; 354 request.team = BPrivate::current_team(); 355 356 TRACE("BMediaRoster::ReleaseNodeAll, node %" B_PRId32 ", port %" B_PRId32 357 ", team %" B_PRId32 "\n", 358 node.node, node.port, BPrivate::current_team()); 359 360 rv = QueryServer(SERVER_RELEASE_NODE_ALL, &request, sizeof(request), &reply, 361 sizeof(reply)); 362 if (rv != B_OK) { 363 ERROR("BMediaRoster::ReleaseNodeAll failed to query media_server, " 364 "retrying local, node %" B_PRId32 ", port %" 365 B_PRId32 ", team %" B_PRId32 "!\n", node.node, node.port, 366 BPrivate::current_team()); 367 node_final_release_command command; 368 rv = SendToPort(node.port, NODE_FINAL_RELEASE, &command, 369 sizeof(command)); 370 if (rv != B_OK) { 371 ERROR("BMediaRoster::ReleaseNodeAll FAILED, node %" B_PRId32 ", port %" 372 B_PRId32 ", team %" B_PRId32 "!\n", node.node, node.port, 373 BPrivate::current_team()); 374 } 375 } 376 return rv; 377} 378 379 380status_t 381BMediaRosterEx::SetNodeCreator(media_node_id node, team_id creator) 382{ 383 server_set_node_creator_request request; 384 server_set_node_creator_reply reply; 385 386 request.node = node; 387 request.creator = creator; 388 return QueryServer(SERVER_SET_NODE_CREATOR, &request, sizeof(request), 389 &reply, sizeof(reply)); 390} 391 392 393status_t 394BMediaRosterEx::GetNode(node_type type, media_node* out_node, 395 int32* out_input_id, BString* out_input_name) 396{ 397 if (out_node == NULL) 398 return B_BAD_VALUE; 399 400 server_get_node_request request; 401 server_get_node_reply reply; 402 status_t rv; 403 404 request.type = type; 405 request.team = BPrivate::current_team(); 406 rv = QueryServer(SERVER_GET_NODE, &request, sizeof(request), &reply, 407 sizeof(reply)); 408 if (rv != B_OK) 409 return rv; 410 411 *out_node = reply.node; 412 if (out_input_id) 413 *out_input_id = reply.input_id; 414 if (out_input_name) 415 *out_input_name = reply.input_name; 416 return rv; 417} 418 419 420status_t 421BMediaRosterEx::SetNode(node_type type, const media_node* node, 422 const dormant_node_info* info, const media_input* input) 423{ 424 server_set_node_request request; 425 server_set_node_reply reply; 426 427 request.type = type; 428 request.use_node = node != NULL; 429 if (node != NULL) 430 request.node = *node; 431 request.use_dni = info != NULL; 432 if (info != NULL) 433 request.dni = *info; 434 request.use_input = input != NULL; 435 if (input != NULL) 436 request.input = *input; 437 438 return QueryServer(SERVER_SET_NODE, &request, sizeof(request), &reply, 439 sizeof(reply)); 440} 441 442 443status_t 444BMediaRosterEx::GetAllOutputs(const media_node& node, List<media_output>* list) 445{ 446 int32 cookie; 447 status_t rv; 448 status_t result; 449 450 PRINT(4, "BMediaRosterEx::GetAllOutputs() node %" B_PRId32 ", port %" 451 B_PRId32 "\n", node.node, node.port); 452 453 if (!(node.kind & B_BUFFER_PRODUCER)) { 454 ERROR("BMediaRosterEx::GetAllOutputs: node %" B_PRId32 " is not a " 455 "B_BUFFER_PRODUCER\n", node.node); 456 return B_MEDIA_BAD_NODE; 457 } 458 459 result = B_OK; 460 cookie = 0; 461 list->MakeEmpty(); 462 for (;;) { 463 producer_get_next_output_request request; 464 producer_get_next_output_reply reply; 465 request.cookie = cookie; 466 rv = QueryPort(node.port, PRODUCER_GET_NEXT_OUTPUT, &request, 467 sizeof(request), &reply, sizeof(reply)); 468 if (rv != B_OK) 469 break; 470 cookie = reply.cookie; 471 if (!list->Insert(reply.output)) { 472 ERROR("GetAllOutputs: list->Insert failed\n"); 473 result = B_ERROR; 474 } 475 #if DEBUG >= 3 476 PRINT(3," next cookie %" B_PRId32 ", ", cookie); 477 PRINT_OUTPUT("output ", reply.output); 478 #endif 479 } 480 481 producer_dispose_output_cookie_request request; 482 producer_dispose_output_cookie_reply reply; 483 QueryPort(node.port, PRODUCER_DISPOSE_OUTPUT_COOKIE, &request, 484 sizeof(request), &reply, sizeof(reply)); 485 486 return result; 487} 488 489 490status_t 491BMediaRosterEx::GetAllOutputs(BBufferProducer* node, List<media_output>* list) 492{ 493 int32 cookie; 494 status_t result; 495 496 PRINT(4, "BMediaRosterEx::GetAllOutputs() (by pointer) node %" B_PRId32 497 ", port %" B_PRId32 "\n", node->ID(), node->ControlPort()); 498 499 result = B_OK; 500 cookie = 0; 501 list->MakeEmpty(); 502 for (;;) { 503 media_output output; 504 if (B_OK != node->GetNextOutput(&cookie, &output)) 505 break; 506 if (!list->Insert(output)) { 507 ERROR("GetAllOutputs: list->Insert failed\n"); 508 result = B_ERROR; 509 } 510 #if DEBUG >= 3 511 PRINT(3," next cookie %" B_PRId32 ", ", cookie); 512 PRINT_OUTPUT("output ", output); 513 #endif 514 } 515 node->DisposeOutputCookie(cookie); 516 return result; 517} 518 519 520status_t 521BMediaRosterEx::GetAllInputs(const media_node& node, List<media_input>* list) 522{ 523 int32 cookie; 524 status_t rv; 525 status_t result; 526 527 PRINT(4, "BMediaRosterEx::GetAllInputs() node %" B_PRId32 ", port %" 528 B_PRId32 "\n", node.node, node.port); 529 530 if (!(node.kind & B_BUFFER_CONSUMER)) { 531 ERROR("BMediaRosterEx::GetAllInputs: node %" B_PRId32 " is not a " 532 "B_BUFFER_CONSUMER\n", node.node); 533 return B_MEDIA_BAD_NODE; 534 } 535 536 result = B_OK; 537 cookie = 0; 538 list->MakeEmpty(); 539 for (;;) { 540 consumer_get_next_input_request request; 541 consumer_get_next_input_reply reply; 542 request.cookie = cookie; 543 rv = QueryPort(node.port, CONSUMER_GET_NEXT_INPUT, &request, 544 sizeof(request), &reply, sizeof(reply)); 545 if (rv != B_OK) 546 break; 547 cookie = reply.cookie; 548 if (!list->Insert(reply.input)) { 549 ERROR("GetAllInputs: list->Insert failed\n"); 550 result = B_ERROR; 551 } 552 #if DEBUG >= 3 553 PRINT(3," next cookie %" B_PRId32 ", ", cookie); 554 PRINT_OUTPUT("input ", reply.input); 555 #endif 556 } 557 558 consumer_dispose_input_cookie_request request; 559 consumer_dispose_input_cookie_reply reply; 560 QueryPort(node.port, CONSUMER_DISPOSE_INPUT_COOKIE, &request, 561 sizeof(request), &reply, sizeof(reply)); 562 563 return result; 564} 565 566 567status_t 568BMediaRosterEx::GetAllInputs(BBufferConsumer* node, List<media_input>* list) 569{ 570 int32 cookie; 571 status_t result; 572 573 PRINT(4, "BMediaRosterEx::GetAllInputs() (by pointer) node %" B_PRId32 574 ", port %" B_PRId32 "\n", node->ID(), node->ControlPort()); 575 576 result = B_OK; 577 cookie = 0; 578 list->MakeEmpty(); 579 for (;;) { 580 media_input input; 581 if (B_OK != node->GetNextInput(&cookie, &input)) 582 break; 583 if (!list->Insert(input)) { 584 ERROR("GetAllInputs: list->Insert failed\n"); 585 result = B_ERROR; 586 } 587 #if DEBUG >= 3 588 PRINT(3," next cookie %" B_PRId32 ", ", cookie); 589 PRINT_INPUT("input ", input); 590 #endif 591 } 592 node->DisposeInputCookie(cookie); 593 return result; 594} 595 596 597status_t 598BMediaRosterEx::PublishOutputs(const media_node& node, List<media_output>* list) 599{ 600 server_publish_outputs_request request; 601 server_publish_outputs_reply reply; 602 media_output* output; 603 media_output* outputs; 604 int32 count; 605 status_t rv; 606 607 count = list->CountItems(); 608 TRACE("PublishOutputs: publishing %" B_PRId32 "\n", count); 609 610 request.node = node; 611 request.count = count; 612 if (count > MAX_OUTPUTS) { 613 void *start_addr; 614 size_t size; 615 size = ROUND_UP_TO_PAGE(count * sizeof(media_output)); 616 request.area = create_area("publish outputs", &start_addr, 617 B_ANY_ADDRESS, size, B_NO_LOCK, 618 B_READ_AREA | B_WRITE_AREA | B_CLONEABLE_AREA); 619 if (request.area < B_OK) { 620 ERROR("PublishOutputs: failed to create area, %#" B_PRIx32 "\n", 621 request.area); 622 return (status_t)request.area; 623 } 624 outputs = static_cast<media_output *>(start_addr); 625 } else { 626 request.area = -1; 627 outputs = request.outputs; 628 } 629 TRACE("PublishOutputs: area %" B_PRId32 "\n", request.area); 630 631 int i; 632 for (i = 0, list->Rewind(); list->GetNext(&output); i++) { 633 ASSERT(i < count); 634 outputs[i] = *output; 635 } 636 637 rv = QueryServer(SERVER_PUBLISH_OUTPUTS, &request, sizeof(request), 638 &reply, sizeof(reply)); 639 640 if (request.area != -1) 641 delete_area(request.area); 642 643 return rv; 644} 645 646 647status_t 648BMediaRosterEx::PublishInputs(const media_node& node, List<media_input>* list) 649{ 650 server_publish_inputs_request request; 651 server_publish_inputs_reply reply; 652 media_input* input; 653 media_input* inputs; 654 int32 count; 655 status_t rv; 656 657 count = list->CountItems(); 658 TRACE("PublishInputs: publishing %" B_PRId32 "\n", count); 659 660 request.node = node; 661 request.count = count; 662 if (count > MAX_INPUTS) { 663 void* start_addr; 664 size_t size; 665 size = ROUND_UP_TO_PAGE(count * sizeof(media_input)); 666 request.area = create_area("publish inputs", &start_addr, 667 B_ANY_ADDRESS, size, B_NO_LOCK, 668 B_READ_AREA | B_WRITE_AREA | B_CLONEABLE_AREA); 669 if (request.area < B_OK) { 670 ERROR("PublishInputs: failed to create area, %#" B_PRIx32 "\n", 671 request.area); 672 return (status_t)request.area; 673 } 674 inputs = static_cast<media_input *>(start_addr); 675 } else { 676 request.area = -1; 677 inputs = request.inputs; 678 } 679 TRACE("PublishInputs: area %" B_PRId32 "\n", request.area); 680 681 int i; 682 for (i = 0, list->Rewind(); list->GetNext(&input); i++) { 683 ASSERT(i < count); 684 inputs[i] = *input; 685 } 686 687 rv = QueryServer(SERVER_PUBLISH_INPUTS, &request, sizeof(request), 688 &reply, sizeof(reply)); 689 690 if (request.area != -1) 691 delete_area(request.area); 692 693 return rv; 694} 695 696 697BTimeSource* 698BMediaRosterEx::MakeTimeSourceObject(media_node_id timeSourceID) 699{ 700 media_node clone; 701 status_t status = GetNodeFor(timeSourceID, &clone); 702 if (status != B_OK) { 703 ERROR("BMediaRosterEx::MakeTimeSourceObject: GetNodeFor failed: %s\n", 704 strerror(status)); 705 return NULL; 706 } 707 708 BTimeSource* source = gTimeSourceObjectManager->GetTimeSource(clone); 709 if (source == NULL) { 710 ERROR("BMediaRosterEx::MakeTimeSourceObject: GetTimeSource failed\n"); 711 return NULL; 712 } 713 714 // TODO: release? 715 ReleaseNode(clone); 716 717 return source; 718} 719 720 721// #pragma mark - public BMediaRoster 722 723 724status_t 725BMediaRoster::GetVideoInput(media_node* _node) 726{ 727 CALLED(); 728 return MediaRosterEx(this)->GetNode(VIDEO_INPUT, _node); 729} 730 731 732status_t 733BMediaRoster::GetAudioInput(media_node* _node) 734{ 735 CALLED(); 736 return MediaRosterEx(this)->GetNode(AUDIO_INPUT, _node); 737} 738 739 740status_t 741BMediaRoster::GetVideoOutput(media_node* _node) 742{ 743 CALLED(); 744 return MediaRosterEx(this)->GetNode(VIDEO_OUTPUT, _node); 745} 746 747 748status_t 749BMediaRoster::GetAudioMixer(media_node* _node) 750{ 751 CALLED(); 752 return MediaRosterEx(this)->GetNode(AUDIO_MIXER, _node); 753} 754 755 756status_t 757BMediaRoster::GetAudioOutput(media_node* _node) 758{ 759 CALLED(); 760 return MediaRosterEx(this)->GetNode(AUDIO_OUTPUT, _node); 761} 762 763 764status_t 765BMediaRoster::GetAudioOutput(media_node* _node, int32* _inputID, 766 BString* _inputName) 767{ 768 CALLED(); 769 return MediaRosterEx(this)->GetNode(AUDIO_OUTPUT_EX, _node, _inputID, 770 _inputName); 771} 772 773 774status_t 775BMediaRoster::GetTimeSource(media_node* _node) 776{ 777 CALLED(); 778 status_t rv; 779 780 // TODO: need to do this in a nicer way. 781 782 rv = MediaRosterEx(this)->GetNode(TIME_SOURCE, _node); 783 if (rv != B_OK) 784 return rv; 785 786 // We don't do reference counting for timesources, that's why we 787 // release the node immediately. 788 ReleaseNode(*_node); 789 790 // we need to remember to not use this node with server side reference counting 791 _node->kind |= NODE_KIND_NO_REFCOUNTING; 792 return B_OK; 793} 794 795 796status_t 797BMediaRoster::SetVideoInput(const media_node& producer) 798{ 799 CALLED(); 800 return MediaRosterEx(this)->SetNode(VIDEO_INPUT, &producer); 801} 802 803 804status_t 805BMediaRoster::SetVideoInput(const dormant_node_info& producer) 806{ 807 CALLED(); 808 return MediaRosterEx(this)->SetNode(VIDEO_INPUT, NULL, &producer); 809} 810 811 812status_t 813BMediaRoster::SetAudioInput(const media_node& producer) 814{ 815 CALLED(); 816 return MediaRosterEx(this)->SetNode(AUDIO_INPUT, &producer); 817} 818 819 820status_t 821BMediaRoster::SetAudioInput(const dormant_node_info& producer) 822{ 823 CALLED(); 824 return MediaRosterEx(this)->SetNode(AUDIO_INPUT, NULL, &producer); 825} 826 827 828status_t 829BMediaRoster::SetVideoOutput(const media_node& consumer) 830{ 831 CALLED(); 832 return MediaRosterEx(this)->SetNode(VIDEO_OUTPUT, &consumer); 833} 834 835 836status_t 837BMediaRoster::SetVideoOutput(const dormant_node_info& consumer) 838{ 839 CALLED(); 840 return MediaRosterEx(this)->SetNode(VIDEO_OUTPUT, NULL, &consumer); 841} 842 843 844status_t 845BMediaRoster::SetAudioOutput(const media_node& consumer) 846{ 847 CALLED(); 848 return MediaRosterEx(this)->SetNode(AUDIO_OUTPUT, &consumer); 849} 850 851 852status_t 853BMediaRoster::SetAudioOutput(const media_input& input) 854{ 855 CALLED(); 856 return MediaRosterEx(this)->SetNode(AUDIO_OUTPUT, NULL, NULL, &input); 857} 858 859 860status_t 861BMediaRoster::SetAudioOutput(const dormant_node_info& consumer) 862{ 863 CALLED(); 864 return MediaRosterEx(this)->SetNode(AUDIO_OUTPUT, NULL, &consumer); 865} 866 867 868status_t 869BMediaRoster::GetNodeFor(media_node_id node, media_node* clone) 870{ 871 CALLED(); 872 if (clone == NULL) 873 return B_BAD_VALUE; 874 if (IS_INVALID_NODEID(node)) 875 return B_MEDIA_BAD_NODE; 876 877 server_get_node_for_request request; 878 server_get_node_for_reply reply; 879 status_t rv; 880 881 request.node_id = node; 882 request.team = BPrivate::current_team(); 883 884 rv = QueryServer(SERVER_GET_NODE_FOR, &request, sizeof(request), &reply, 885 sizeof(reply)); 886 if (rv != B_OK) 887 return rv; 888 889 *clone = reply.clone; 890 return B_OK; 891} 892 893 894status_t 895BMediaRoster::GetSystemTimeSource(media_node* clone) 896{ 897 CALLED(); 898 status_t rv; 899 900 // TODO: need to do this in a nicer way. 901 902 rv = MediaRosterEx(this)->GetNode(SYSTEM_TIME_SOURCE, clone); 903 if (rv != B_OK) 904 return rv; 905 906 // We don't do reference counting for timesources, that's why we 907 // release the node immediately. 908 ReleaseNode(*clone); 909 910 // we need to remember to not use this node with server side reference 911 // counting 912 clone->kind |= NODE_KIND_NO_REFCOUNTING; 913 914 return B_OK; 915} 916 917 918status_t 919BMediaRoster::ReleaseNode(const media_node& node) 920{ 921 CALLED(); 922 if (IS_INVALID_NODE(node)) 923 return B_MEDIA_BAD_NODE; 924 925 if (node.kind & NODE_KIND_NO_REFCOUNTING) { 926 TRACE("BMediaRoster::ReleaseNode, trying to release reference " 927 "counting disabled timesource, node %" B_PRId32 ", port %" B_PRId32 928 ", team %" B_PRId32 "\n", node.node, node.port, 929 BPrivate::current_team()); 930 return B_OK; 931 } 932 933 server_release_node_request request; 934 server_release_node_reply reply; 935 status_t rv; 936 937 request.node = node; 938 request.team = BPrivate::current_team(); 939 940 TRACE("BMediaRoster::ReleaseNode, node %" B_PRId32 ", port %" B_PRId32 941 ", team %" B_PRId32 "\n", node.node, node.port, 942 BPrivate::current_team()); 943 944 rv = QueryServer(SERVER_RELEASE_NODE, &request, sizeof(request), &reply, 945 sizeof(reply)); 946 if (rv != B_OK) { 947 ERROR("BMediaRoster::ReleaseNode FAILED, node %" B_PRId32 ", port %" 948 B_PRId32 ", team %" B_PRId32 "!\n", node.node, node.port, 949 BPrivate::current_team()); 950 } 951 return rv; 952} 953 954 955BTimeSource* 956BMediaRoster::MakeTimeSourceFor(const media_node& forNode) 957{ 958 // MakeTimeSourceFor() returns a BTimeSource object 959 // corresponding to the specified node's time source. 960 961 CALLED(); 962 963 if (IS_SYSTEM_TIMESOURCE(forNode)) { 964 // special handling for the system time source 965 TRACE("BMediaRoster::MakeTimeSourceFor, asked for system time " 966 "source\n"); 967 return MediaRosterEx(this)->MakeTimeSourceObject( 968 NODE_SYSTEM_TIMESOURCE_ID); 969 } 970 971 if (IS_INVALID_NODE(forNode)) { 972 ERROR("BMediaRoster::MakeTimeSourceFor: for_node invalid, node %" 973 B_PRId32 ", port %" B_PRId32 ", kinds 0x%" B_PRIx32 "\n", 974 forNode.node, forNode.port, forNode.kind); 975 return NULL; 976 } 977 978 TRACE("BMediaRoster::MakeTimeSourceFor: node %" B_PRId32 " enter\n", 979 forNode.node); 980 981 node_get_timesource_request request; 982 node_get_timesource_reply reply; 983 BTimeSource *source; 984 status_t rv; 985 986 // ask the node to get it's current timesource id 987 rv = QueryPort(forNode.port, NODE_GET_TIMESOURCE, &request, 988 sizeof(request), &reply, sizeof(reply)); 989 if (rv != B_OK) { 990 ERROR("BMediaRoster::MakeTimeSourceFor: request failed\n"); 991 return NULL; 992 } 993 994 source = MediaRosterEx(this)->MakeTimeSourceObject(reply.timesource_id); 995 996 TRACE("BMediaRoster::MakeTimeSourceFor: node %" B_PRId32 " leave\n", 997 forNode.node); 998 999 return source; 1000} 1001 1002 1003status_t 1004BMediaRoster::Connect(const media_source& from, const media_destination& to, 1005 media_format* _format, media_output* _output, media_input* _input) 1006{ 1007 return BMediaRoster::Connect(from, to, _format, _output, _input, 0); 1008} 1009 1010 1011status_t 1012BMediaRoster::Connect(const media_source& from, const media_destination& to, 1013 media_format* io_format, media_output* out_output, media_input* out_input, 1014 uint32 in_flags, void* _reserved) 1015{ 1016 CALLED(); 1017 if (io_format == NULL || out_output == NULL || out_input == NULL) 1018 return B_BAD_VALUE; 1019 if (IS_INVALID_SOURCE(from)) { 1020 ERROR("BMediaRoster::Connect: media_source invalid\n"); 1021 return B_MEDIA_BAD_SOURCE; 1022 } 1023 if (IS_INVALID_DESTINATION(to)) { 1024 ERROR("BMediaRoster::Connect: media_destination invalid\n"); 1025 return B_MEDIA_BAD_DESTINATION; 1026 } 1027 1028 status_t rv; 1029 1030 // find the output and input nodes 1031 // TODO: isn't there a easier way? 1032 media_node sourcenode; 1033 media_node destnode; 1034 rv = GetNodeFor(NodeIDFor(from.port), &sourcenode); 1035 if (rv != B_OK) { 1036 ERROR("BMediaRoster::Connect: Can't find source node for port %" 1037 B_PRId32 "\n", from.port); 1038 return B_MEDIA_BAD_SOURCE; 1039 } 1040 ReleaseNode(sourcenode); 1041 rv = GetNodeFor(NodeIDFor(to.port), &destnode); 1042 if (rv != B_OK) { 1043 ERROR("BMediaRoster::Connect: Can't find destination node for port " 1044 "%" B_PRId32 "\n", to.port); 1045 return B_MEDIA_BAD_DESTINATION; 1046 } 1047 ReleaseNode(destnode); 1048 1049 if (!(sourcenode.kind & B_BUFFER_PRODUCER)) { 1050 ERROR("BMediaRoster::Connect: source node %" B_PRId32 " is not a " 1051 "B_BUFFER_PRODUCER\n", sourcenode.node); 1052 return B_MEDIA_BAD_SOURCE; 1053 } 1054 if (!(destnode.kind & B_BUFFER_CONSUMER)) { 1055 ERROR("BMediaRoster::Connect: destination node %" B_PRId32 " is not a " 1056 "B_BUFFER_CONSUMER\n", destnode.node); 1057 return B_MEDIA_BAD_DESTINATION; 1058 } 1059 1060 producer_format_proposal_request request1; 1061 producer_format_proposal_reply reply1; 1062 1063 PRINT_FORMAT("BMediaRoster::Connect calling " 1064 "BBufferProducer::FormatProposal with format ", *io_format); 1065 1066 // BBufferProducer::FormatProposal 1067 request1.output = from; 1068 request1.format = *io_format; 1069 rv = QueryPort(from.port, PRODUCER_FORMAT_PROPOSAL, &request1, 1070 sizeof(request1), &reply1, sizeof(reply1)); 1071 if (rv != B_OK) { 1072 ERROR("BMediaRoster::Connect: aborted after " 1073 "BBufferProducer::FormatProposal, status = %#" B_PRIx32 "\n",rv); 1074 return rv; 1075 } 1076 // reply1.format now contains the format proposed by the producer 1077 1078 consumer_accept_format_request request2; 1079 consumer_accept_format_reply reply2; 1080 1081 PRINT_FORMAT("BMediaRoster::Connect calling " 1082 "BBufferConsumer::AcceptFormat with format ", reply1.format); 1083 1084 // BBufferConsumer::AcceptFormat 1085 request2.dest = to; 1086 request2.format = reply1.format; 1087 rv = QueryPort(to.port, CONSUMER_ACCEPT_FORMAT, &request2, 1088 sizeof(request2), &reply2, sizeof(reply2)); 1089 if (rv != B_OK) { 1090 ERROR("BMediaRoster::Connect: aborted after " 1091 "BBufferConsumer::AcceptFormat, status = %#" B_PRIx32 "\n",rv); 1092 return rv; 1093 } 1094 // reply2.format now contains the format accepted by the consumer 1095 1096 // BBufferProducer::PrepareToConnect 1097 producer_prepare_to_connect_request request3; 1098 producer_prepare_to_connect_reply reply3; 1099 1100 PRINT_FORMAT("BMediaRoster::Connect calling " 1101 "BBufferProducer::PrepareToConnect with format", reply2.format); 1102 1103 request3.source = from; 1104 request3.destination = to; 1105 request3.format = reply2.format; 1106 strcpy(request3.name, "XXX some default name"); // TODO: fix this 1107 rv = QueryPort(from.port, PRODUCER_PREPARE_TO_CONNECT, &request3, 1108 sizeof(request3), &reply3, sizeof(reply3)); 1109 if (rv != B_OK) { 1110 ERROR("BMediaRoster::Connect: aborted after " 1111 "BBufferProducer::PrepareToConnect, status = %#" B_PRIx32 "\n", rv); 1112 return rv; 1113 } 1114 // reply3.format is still our pretty media format 1115 // reply3.out_source the real source to be used for the connection 1116 // reply3.name the name BBufferConsumer::Connected will see in the 1117 // outInput->name argument 1118 1119 // BBufferConsumer::Connected 1120 consumer_connected_request request4; 1121 consumer_connected_reply reply4; 1122 status_t con_status; 1123 1124 PRINT_FORMAT("BMediaRoster::Connect calling BBufferConsumer::Connected() " 1125 "with format ", reply3.format); 1126 1127 request4.input.node = destnode; 1128 request4.input.source = reply3.out_source; 1129 request4.input.destination = to; 1130 request4.input.format = reply3.format; 1131 strcpy(request4.input.name, reply3.name); 1132 1133 con_status = QueryPort(to.port, CONSUMER_CONNECTED, &request4, 1134 sizeof(request4), &reply4, sizeof(reply4)); 1135 if (con_status != B_OK) { 1136 ERROR("BMediaRoster::Connect: aborting after " 1137 "BBufferConsumer::Connected, status = %#" B_PRIx32 "\n", 1138 con_status); 1139 // we do NOT return here! 1140 } 1141 // con_status contains the status code to be supplied to 1142 // BBufferProducer::Connect's status argument 1143 // reply4.input contains the media_input that describes the connection 1144 // from the consumer point of view 1145 1146 // BBufferProducer::Connect 1147 producer_connect_request request5; 1148 producer_connect_reply reply5; 1149 1150 PRINT_FORMAT("BMediaRoster::Connect calling BBufferProducer::Connect with " 1151 "format ", reply4.input.format); 1152 1153 request5.error = con_status; 1154 request5.source = reply3.out_source; 1155 request5.destination = reply4.input.destination; 1156 request5.format = reply4.input.format; 1157 strcpy(request5.name, reply4.input.name); 1158 rv = QueryPort(reply4.input.source.port, PRODUCER_CONNECT, &request5, 1159 sizeof(request5), &reply5, sizeof(reply5)); 1160 if (con_status != B_OK) { 1161 ERROR("BMediaRoster::Connect: aborted\n"); 1162 return con_status; 1163 } 1164 if (rv != B_OK) { 1165 ERROR("BMediaRoster::Connect: aborted after BBufferProducer::Connect()" 1166 ", status = %#" B_PRIx32 "\n", rv); 1167 return rv; 1168 } 1169 // reply5.name contains the name assigned to the connection by the producer 1170 1171 // initilize connection info 1172 *io_format = reply4.input.format; 1173 *out_input = reply4.input; 1174 out_output->node = sourcenode; 1175 out_output->source = reply4.input.source; 1176 out_output->destination = reply4.input.destination; 1177 out_output->format = reply4.input.format; 1178 strcpy(out_output->name, reply5.name); 1179 1180 // the connection is now made 1181 PRINT_FORMAT(" format", *io_format); 1182 PRINT_INPUT(" input", *out_input); 1183 PRINT_OUTPUT(" output", *out_output); 1184 1185 // TODO: register connection with server 1186 // TODO: we should just send a notification, instead of republishing all 1187 // endpoints 1188 List<media_output> outlist; 1189 List<media_input> inlist; 1190 if (MediaRosterEx(this)->GetAllOutputs(out_output->node , &outlist) == B_OK) 1191 MediaRosterEx(this)->PublishOutputs(out_output->node , &outlist); 1192 if (MediaRosterEx(this)->GetAllInputs(out_input->node , &inlist) == B_OK) 1193 MediaRosterEx(this)->PublishInputs(out_input->node, &inlist); 1194 1195 // TODO: if (mute) BBufferProducer::EnableOutput(false) 1196 if (in_flags & B_CONNECT_MUTED) { 1197 } 1198 1199 // send a notification 1200 BPrivate::media::notifications::ConnectionMade(*out_input, *out_output, 1201 *io_format); 1202 1203 return B_OK; 1204}; 1205 1206 1207status_t 1208BMediaRoster::Disconnect(media_node_id source_nodeid, 1209 const media_source& source, media_node_id destination_nodeid, 1210 const media_destination& destination) 1211{ 1212 CALLED(); 1213 if (IS_INVALID_NODEID(source_nodeid)) { 1214 ERROR("BMediaRoster::Disconnect: source media_node_id invalid\n"); 1215 return B_MEDIA_BAD_SOURCE; 1216 } 1217 if (IS_INVALID_NODEID(destination_nodeid)) { 1218 ERROR("BMediaRoster::Disconnect: destination media_node_id invalid\n"); 1219 return B_MEDIA_BAD_DESTINATION; 1220 } 1221 if (IS_INVALID_SOURCE(source)) { 1222 ERROR("BMediaRoster::Disconnect: media_source invalid\n"); 1223 return B_MEDIA_BAD_SOURCE; 1224 } 1225 if (IS_INVALID_DESTINATION(destination)) { 1226 ERROR("BMediaRoster::Disconnect: media_destination invalid\n"); 1227 return B_MEDIA_BAD_DESTINATION; 1228 } 1229 1230 producer_disconnect_request request2; 1231 producer_disconnect_reply reply2; 1232 consumer_disconnected_request request1; 1233 consumer_disconnected_reply reply1; 1234 status_t rv1, rv2; 1235 1236 // TODO: we should ask the server if this connection really exists 1237 1238 request1.source = source; 1239 request1.destination = destination; 1240 request2.source = source; 1241 request2.destination = destination; 1242 1243 rv1 = QueryPort(source.port, PRODUCER_DISCONNECT, &request1, 1244 sizeof(request1), &reply1, sizeof(reply1)); 1245 rv2 = QueryPort(destination.port, CONSUMER_DISCONNECTED, &request2, 1246 sizeof(request2), &reply2, sizeof(reply2)); 1247 1248 // TODO: unregister connection with server 1249 // TODO: we should just send a notification, instead of republishing all 1250 // endpoints 1251 List<media_output> outlist; 1252 List<media_input> inlist; 1253 media_node sourcenode; 1254 media_node destnode; 1255 if (GetNodeFor(source_nodeid, &sourcenode) == B_OK) { 1256 if (!(sourcenode.kind & B_BUFFER_PRODUCER)) { 1257 ERROR("BMediaRoster::Disconnect: source_nodeid %" B_PRId32 1258 " is not a B_BUFFER_PRODUCER\n", source_nodeid); 1259 } 1260 if (MediaRosterEx(this)->GetAllOutputs(sourcenode , &outlist) == B_OK) 1261 MediaRosterEx(this)->PublishOutputs(sourcenode , &outlist); 1262 ReleaseNode(sourcenode); 1263 } else { 1264 ERROR("BMediaRoster::Disconnect: GetNodeFor source_nodeid %" B_PRId32 1265 " failed\n", source_nodeid); 1266 } 1267 if (GetNodeFor(destination_nodeid, &destnode) == B_OK) { 1268 if (!(destnode.kind & B_BUFFER_CONSUMER)) { 1269 ERROR("BMediaRoster::Disconnect: destination_nodeid %" B_PRId32 1270 " is not a B_BUFFER_CONSUMER\n", destination_nodeid); 1271 } 1272 if (MediaRosterEx(this)->GetAllInputs(destnode , &inlist) == B_OK) 1273 MediaRosterEx(this)->PublishInputs(destnode, &inlist); 1274 ReleaseNode(destnode); 1275 } else { 1276 ERROR("BMediaRoster::Disconnect: GetNodeFor destination_nodeid %" 1277 B_PRId32 " failed\n", destination_nodeid); 1278 } 1279 1280 // send a notification 1281 BPrivate::media::notifications::ConnectionBroken(source, destination); 1282 1283 return rv1 != B_OK || rv2 != B_OK ? B_ERROR : B_OK; 1284} 1285 1286 1287status_t 1288BMediaRoster::Disconnect(const media_output& output, const media_input& input) 1289{ 1290 if (IS_INVALID_NODEID(output.node.node)) { 1291 printf("BMediaRoster::Disconnect: output.node.node %" B_PRId32 1292 " invalid\n", output.node.node); 1293 return B_MEDIA_BAD_SOURCE; 1294 } 1295 if (IS_INVALID_NODEID(input.node.node)) { 1296 printf("BMediaRoster::Disconnect: input.node.node %" B_PRId32 1297 " invalid\n", input.node.node); 1298 return B_MEDIA_BAD_DESTINATION; 1299 } 1300 if (!(output.node.kind & B_BUFFER_PRODUCER)) { 1301 printf("BMediaRoster::Disconnect: output.node.kind 0x%" B_PRIx32 1302 " is no B_BUFFER_PRODUCER\n", output.node.kind); 1303 return B_MEDIA_BAD_SOURCE; 1304 } 1305 if (!(input.node.kind & B_BUFFER_CONSUMER)) { 1306 printf("BMediaRoster::Disconnect: input.node.kind 0x%" B_PRIx32 1307 " is no B_BUFFER_PRODUCER\n", input.node.kind); 1308 return B_MEDIA_BAD_DESTINATION; 1309 } 1310 if (input.source.port != output.source.port) { 1311 printf("BMediaRoster::Disconnect: input.source.port %" B_PRId32 1312 " doesn't match output.source.port %" B_PRId32 "\n", 1313 input.source.port, output.source.port); 1314 return B_MEDIA_BAD_SOURCE; 1315 } 1316 if (input.source.id != output.source.id) { 1317 printf("BMediaRoster::Disconnect: input.source.id %" B_PRId32 1318 " doesn't match output.source.id %" B_PRId32 "\n", input.source.id, 1319 output.source.id); 1320 return B_MEDIA_BAD_SOURCE; 1321 } 1322 if (input.destination.port != output.destination.port) { 1323 printf("BMediaRoster::Disconnect: input.destination.port %" B_PRId32 1324 " doesn't match output.destination.port %" B_PRId32 "\n", 1325 input.destination.port, output.destination.port); 1326 return B_MEDIA_BAD_DESTINATION; 1327 } 1328 if (input.destination.id != output.destination.id) { 1329 printf("BMediaRoster::Disconnect: input.destination.id %" B_PRId32 1330 " doesn't match output.destination.id %" B_PRId32 "\n", 1331 input.destination.id, output.destination.id); 1332 return B_MEDIA_BAD_DESTINATION; 1333 } 1334 1335 return Disconnect(output.node.node, output.source, input.node.node, 1336 input.destination); 1337} 1338 1339 1340status_t 1341BMediaRoster::StartNode(const media_node& node, bigtime_t atPerformanceTime) 1342{ 1343 CALLED(); 1344 if (node.node <= 0) 1345 return B_MEDIA_BAD_NODE; 1346 1347 TRACE("BMediaRoster::StartNode, node %" B_PRId32 ", at perf %" B_PRId64 1348 "\n", node.node, atPerformanceTime); 1349 1350 node_start_command command; 1351 command.performance_time = atPerformanceTime; 1352 1353 return SendToPort(node.port, NODE_START, &command, sizeof(command)); 1354} 1355 1356 1357status_t 1358BMediaRoster::StopNode(const media_node& node, bigtime_t atPerformanceTime, 1359 bool immediate) 1360{ 1361 CALLED(); 1362 if (IS_INVALID_NODE(node)) 1363 return B_MEDIA_BAD_NODE; 1364 1365 TRACE("BMediaRoster::StopNode, node %" B_PRId32 ", at perf %" B_PRId64 1366 " %s\n", node.node, atPerformanceTime, immediate ? "NOW" : ""); 1367 1368 node_stop_command command; 1369 command.performance_time = atPerformanceTime; 1370 command.immediate = immediate; 1371 1372 return SendToPort(node.port, NODE_STOP, &command, sizeof(command)); 1373} 1374 1375 1376status_t 1377BMediaRoster::SeekNode(const media_node& node, bigtime_t toMediaTime, 1378 bigtime_t atPerformanceTime) 1379{ 1380 CALLED(); 1381 if (IS_INVALID_NODE(node)) 1382 return B_MEDIA_BAD_NODE; 1383 1384 TRACE("BMediaRoster::SeekNode, node %" B_PRId32 ", at perf %" B_PRId64 1385 ", to perf %" B_PRId64 "\n", node.node, atPerformanceTime, toMediaTime); 1386 1387 node_seek_command command; 1388 command.media_time = toMediaTime; 1389 command.performance_time = atPerformanceTime; 1390 1391 return SendToPort(node.port, NODE_SEEK, &command, sizeof(command)); 1392} 1393 1394 1395status_t 1396BMediaRoster::StartTimeSource(const media_node& node, bigtime_t atRealTime) 1397{ 1398 CALLED(); 1399 if (IS_SYSTEM_TIMESOURCE(node)) { 1400 // TODO: debug this 1401 //ERROR("BMediaRoster::StartTimeSource node %" B_PRId32 " is system timesource\n", node.node); 1402 return B_OK; 1403 } 1404// if (IS_SHADOW_TIMESOURCE(node)) { 1405// // TODO: debug this 1406// ERROR("BMediaRoster::StartTimeSource node %" B_PRId32 " is shadow timesource\n", node.node); 1407// return B_OK; 1408// } 1409 if (IS_INVALID_NODE(node)) { 1410 ERROR("BMediaRoster::StartTimeSource node %" B_PRId32 " invalid\n", 1411 node.node); 1412 return B_MEDIA_BAD_NODE; 1413 } 1414 if ((node.kind & B_TIME_SOURCE) == 0) { 1415 ERROR("BMediaRoster::StartTimeSource node %" B_PRId32 1416 " is no timesource\n", node.node); 1417 return B_MEDIA_BAD_NODE; 1418 } 1419 1420 TRACE("BMediaRoster::StartTimeSource, node %" B_PRId32 ", at real %" 1421 B_PRId64 "\n", node.node, atRealTime); 1422 1423 BTimeSource::time_source_op_info msg; 1424 msg.op = BTimeSource::B_TIMESOURCE_START; 1425 msg.real_time = atRealTime; 1426 1427 return write_port(node.port, TIMESOURCE_OP, &msg, sizeof(msg)); 1428} 1429 1430 1431status_t 1432BMediaRoster::StopTimeSource(const media_node& node, bigtime_t atRealTime, 1433 bool immediate) 1434{ 1435 CALLED(); 1436 if (IS_SYSTEM_TIMESOURCE(node)) { 1437 // TODO: debug this 1438 //ERROR("BMediaRoster::StopTimeSource node %ld is system timesource\n", node.node); 1439 return B_OK; 1440 } 1441// if (IS_SHADOW_TIMESOURCE(node)) { 1442// // TODO: debug this 1443// ERROR("BMediaRoster::StopTimeSource node %ld is shadow timesource\n", node.node); 1444// return B_OK; 1445// } 1446 if (IS_INVALID_NODE(node)) { 1447 ERROR("BMediaRoster::StopTimeSource node %" B_PRId32 " invalid\n", 1448 node.node); 1449 return B_MEDIA_BAD_NODE; 1450 } 1451 if ((node.kind & B_TIME_SOURCE) == 0) { 1452 ERROR("BMediaRoster::StopTimeSource node %" B_PRId32 " is no " 1453 "timesource\n", node.node); 1454 return B_MEDIA_BAD_NODE; 1455 } 1456 1457 TRACE("BMediaRoster::StopTimeSource, node %" B_PRId32 ", at real %" B_PRId64 1458 " %s\n", node.node, atRealTime, immediate ? "NOW" : ""); 1459 1460 BTimeSource::time_source_op_info msg; 1461 msg.op = immediate ? BTimeSource::B_TIMESOURCE_STOP_IMMEDIATELY 1462 : BTimeSource::B_TIMESOURCE_STOP; 1463 msg.real_time = atRealTime; 1464 1465 return write_port(node.port, TIMESOURCE_OP, &msg, sizeof(msg)); 1466} 1467 1468 1469status_t 1470BMediaRoster::SeekTimeSource(const media_node& node, 1471 bigtime_t toPerformanceTime, bigtime_t atRealTime) 1472{ 1473 CALLED(); 1474 if (IS_SYSTEM_TIMESOURCE(node)) { 1475 // TODO: debug this 1476 // ERROR("BMediaRoster::SeekTimeSource node %ld is system timesource\n", node.node); 1477 // you can't seek the system time source, but 1478 // returning B_ERROR would break StampTV 1479 return B_OK; 1480 } 1481// if (IS_SHADOW_TIMESOURCE(node)) { 1482// // TODO: debug this 1483// ERROR("BMediaRoster::SeekTimeSource node %ld is shadow timesource\n", node.node); 1484// return B_OK; 1485// } 1486 if (IS_INVALID_NODE(node)) { 1487 ERROR("BMediaRoster::SeekTimeSource node %" B_PRId32 " invalid\n", 1488 node.node); 1489 return B_MEDIA_BAD_NODE; 1490 } 1491 if ((node.kind & B_TIME_SOURCE) == 0) { 1492 ERROR("BMediaRoster::SeekTimeSource node %" B_PRId32 1493 " is no timesource\n", node.node); 1494 return B_MEDIA_BAD_NODE; 1495 } 1496 1497 TRACE("BMediaRoster::SeekTimeSource, node %" B_PRId32 ", at real %" B_PRId64 1498 ", to perf %" B_PRId64 "\n", node.node, atRealTime, toPerformanceTime); 1499 1500 BTimeSource::time_source_op_info msg; 1501 msg.op = BTimeSource::B_TIMESOURCE_SEEK; 1502 msg.real_time = atRealTime; 1503 msg.performance_time = toPerformanceTime; 1504 1505 return write_port(node.port, TIMESOURCE_OP, &msg, sizeof(msg)); 1506} 1507 1508 1509status_t 1510BMediaRoster::SyncToNode(const media_node& node, bigtime_t atTime, 1511 bigtime_t timeout) 1512{ 1513 TRACE("BMediaRoster::SyncToNode, node %" B_PRId32 ", at real %" B_PRId64 1514 ", at timeout %" B_PRId64 "\n", node.node, atTime, timeout); 1515 if (IS_INVALID_NODE(node)) 1516 return B_MEDIA_BAD_NODE; 1517 1518 port_id waitPort = create_port(1, "SyncToNode wait port"); 1519 if (waitPort < B_OK) 1520 return waitPort; 1521 1522 node_sync_to_request request; 1523 node_sync_to_reply reply; 1524 request.performance_time = atTime; 1525 request.port = waitPort; 1526 1527 status_t status = QueryPort(node.port, NODE_SYNC_TO, &request, 1528 sizeof(request), &reply, sizeof(reply)); 1529 1530 if (status == B_OK) { 1531 ssize_t readSize = read_port_etc(waitPort, NULL, &status, 1532 sizeof(status), B_TIMEOUT, timeout); 1533 if (readSize < 0) 1534 status = readSize; 1535 } 1536 close_port(waitPort); 1537 delete_port(waitPort); 1538 return status; 1539} 1540 1541 1542status_t 1543BMediaRoster::SetRunModeNode(const media_node& node, BMediaNode::run_mode mode) 1544{ 1545 TRACE("BMediaRoster::SetRunModeNode, node %" B_PRId32 ", mode %d\n", 1546 node.node, mode); 1547 if (IS_INVALID_NODE(node)) 1548 return B_MEDIA_BAD_NODE; 1549 1550 node_set_run_mode_command msg; 1551 msg.mode = mode; 1552 1553 return write_port(node.port, NODE_SET_RUN_MODE, &msg, sizeof(msg)); 1554} 1555 1556 1557status_t 1558BMediaRoster::PrerollNode(const media_node& node) 1559{ 1560 CALLED(); 1561 if (IS_INVALID_NODE(node)) 1562 return B_MEDIA_BAD_NODE; 1563 1564 char dummy = 0; 1565 return write_port(node.port, NODE_PREROLL, &dummy, sizeof(dummy)); 1566} 1567 1568 1569status_t 1570BMediaRoster::RollNode(const media_node& node, bigtime_t startPerformance, 1571 bigtime_t stopPerformance, bigtime_t atMediaTime) 1572{ 1573 CALLED(); 1574 if (IS_INVALID_NODE(node)) 1575 return B_MEDIA_BAD_NODE; 1576 1577 TRACE("BMediaRoster::RollNode, node %" B_PRId32 ", at start perf %" 1578 B_PRId64 ", at stop perf %" B_PRId64 ", at media time %" 1579 B_PRId64 "\n", node.node, startPerformance, 1580 stopPerformance, atMediaTime); 1581 1582 node_roll_command command; 1583 command.start_performance_time = startPerformance; 1584 command.stop_performance_time = stopPerformance; 1585 command.seek_media_time = atMediaTime; 1586 1587 return write_port(node.port, NODE_ROLL, &command, sizeof(command)); 1588} 1589 1590 1591status_t 1592BMediaRoster::SetProducerRunModeDelay(const media_node& node, 1593 bigtime_t delay, BMediaNode::run_mode mode) 1594{ 1595 TRACE("BMediaRoster::SetProducerRunModeDelay, node %" B_PRId32 ", delay %" 1596 B_PRId64 ", mode %d\n", node.node, delay, mode); 1597 if (IS_INVALID_NODE(node)) 1598 return B_MEDIA_BAD_NODE; 1599 if ((node.kind & B_BUFFER_PRODUCER) == 0) 1600 return B_MEDIA_BAD_NODE; 1601 1602 producer_set_run_mode_delay_command command; 1603 command.mode = mode; 1604 command.delay = delay; 1605 1606 return SendToPort(node.port, PRODUCER_SET_RUN_MODE_DELAY, &command, 1607 sizeof(command)); 1608} 1609 1610 1611status_t 1612BMediaRoster::SetProducerRate(const media_node& producer, int32 numer, 1613 int32 denom) 1614{ 1615 CALLED(); 1616 if (IS_INVALID_NODE(producer)) 1617 return B_MEDIA_BAD_NODE; 1618 if ((producer.kind & B_BUFFER_PRODUCER) == 0) 1619 return B_MEDIA_BAD_NODE; 1620 1621 producer_set_play_rate_request request; 1622 request.numer = numer; 1623 request.denom = denom; 1624 status_t status = write_port(producer.node, PRODUCER_SET_PLAY_RATE, 1625 &request, sizeof(request)); 1626 if (status != B_OK) 1627 return status; 1628 1629 producer_set_play_rate_reply reply; 1630 int32 code; 1631 status = read_port(request.reply_port, &code, &reply, sizeof(reply)); 1632 1633 return status < B_OK ? status : reply.result; 1634} 1635 1636 1637/*! Nodes will have available inputs/outputs as long as they are capable 1638 of accepting more connections. The node may create an additional 1639 output or input as the currently available is taken into usage. 1640*/ 1641status_t 1642BMediaRoster::GetLiveNodeInfo(const media_node& node, 1643 live_node_info* out_live_info) 1644{ 1645 CALLED(); 1646 if (out_live_info == NULL) 1647 return B_BAD_VALUE; 1648 if (IS_INVALID_NODE(node)) 1649 return B_MEDIA_BAD_NODE; 1650 1651 server_get_live_node_info_request request; 1652 server_get_live_node_info_reply reply; 1653 status_t rv; 1654 1655 request.node = node; 1656 1657 rv = QueryServer(SERVER_GET_LIVE_NODE_INFO, &request, sizeof(request), 1658 &reply, sizeof(reply)); 1659 if (rv != B_OK) 1660 return rv; 1661 1662 *out_live_info = reply.live_info; 1663 return B_OK; 1664} 1665 1666 1667status_t 1668BMediaRoster::GetLiveNodes(live_node_info* liveNodes, int32* _totalCount, 1669 const media_format* hasInput, const media_format* hasOutput, 1670 const char* name, uint64 nodeKinds) 1671{ 1672 CALLED(); 1673 if (liveNodes == NULL || _totalCount == NULL || *_totalCount <= 0) 1674 return B_BAD_VALUE; 1675 1676 // TODO: we also support the wildcard search as GetDormantNodes does. 1677 // This needs to be documented 1678 1679 server_get_live_nodes_request request; 1680 request.team = BPrivate::current_team(); 1681 1682 request.max_count = *_totalCount; 1683 request.has_input = hasInput != NULL; 1684 if (hasInput != NULL) { 1685 // TODO: we should not make a flat copy of media_format 1686 request.input_format = *hasInput; 1687 } 1688 request.has_output = hasOutput != NULL; 1689 if (hasOutput != NULL) { 1690 // TODO: we should not make a flat copy of media_format 1691 request.output_format = *hasOutput; 1692 } 1693 request.has_name = name != NULL; 1694 if (name != NULL) 1695 strlcpy(request.name, name, sizeof(request.name)); 1696 request.require_kinds = nodeKinds; 1697 1698 server_get_live_nodes_reply reply; 1699 status_t status = QueryServer(SERVER_GET_LIVE_NODES, &request, 1700 sizeof(request), &reply, sizeof(reply)); 1701 if (status != B_OK) { 1702 ERROR("BMediaRoster::GetLiveNodes failed querying server: %s\n", 1703 strerror(status)); 1704 *_totalCount = 0; 1705 return status; 1706 } 1707 1708 const live_node_info* info; 1709 if (reply.area >= 0) 1710 info = (live_node_info*)reply.address; 1711 else 1712 info = reply.live_info; 1713 1714 for (int32 i = 0; i < reply.count; i++) 1715 liveNodes[i] = info[i]; 1716 1717 if (reply.area >= 0) 1718 delete_area(reply.area); 1719 1720 *_totalCount = reply.count; 1721 return B_OK; 1722} 1723 1724 1725status_t 1726BMediaRoster::GetFreeInputsFor(const media_node& node, 1727 media_input * out_free_inputs, int32 buf_num_inputs, 1728 int32 * out_total_count, media_type filter_type) 1729{ 1730 CALLED(); 1731 if (IS_INVALID_NODE(node)) { 1732 ERROR("BMediaRoster::GetFreeInputsFor: node %" B_PRId32 ", port %" 1733 B_PRId32 " invalid\n", node.node, node.port); 1734 return B_MEDIA_BAD_NODE; 1735 } 1736 if ((node.kind & B_BUFFER_CONSUMER) == 0) { 1737 ERROR("BMediaRoster::GetFreeInputsFor: node %" B_PRId32 ", port %" 1738 B_PRId32 " is not a consumer\n", node.node, node.port); 1739 return B_MEDIA_BAD_NODE; 1740 } 1741 if (out_free_inputs == NULL || out_total_count == NULL) 1742 return B_BAD_VALUE; 1743 1744 List<media_input> list; 1745 media_input *input; 1746 status_t rv; 1747 1748 *out_total_count = 0; 1749 1750 rv = MediaRosterEx(this)->GetAllInputs(node, &list); 1751 if (B_OK != rv) 1752 return rv; 1753 1754 PRINT(4, "BMediaRoster::GetFreeInputsFor node %" B_PRId32 ", max %" B_PRId32 1755 ", filter-type %" B_PRId32 "\n", node.node, buf_num_inputs, 1756 filter_type); 1757 1758 int32 i; 1759 for (i = 0, list.Rewind(); list.GetNext(&input);) { 1760 if (filter_type != B_MEDIA_UNKNOWN_TYPE 1761 && filter_type != input->format.type) { 1762 // media_type used, but doesn't match 1763 continue; 1764 } 1765 if (input->source != media_source::null) { 1766 // consumer source already connected 1767 continue; 1768 } 1769 1770 out_free_inputs[i] = *input; 1771 *out_total_count += 1; 1772 buf_num_inputs -= 1; 1773 #if DEBUG >= 3 1774 PRINT_OUTPUT(" input", out_free_inputs[i]); 1775 #endif 1776 if (buf_num_inputs == 0) 1777 break; 1778 i++; 1779 } 1780 1781 MediaRosterEx(this)->PublishInputs(node, &list); 1782 return B_OK; 1783} 1784 1785 1786status_t 1787BMediaRoster::GetConnectedInputsFor(const media_node& node, 1788 media_input* out_active_inputs, int32 buf_num_inputs, 1789 int32* out_total_count) 1790{ 1791 CALLED(); 1792 if (IS_INVALID_NODE(node) || (node.kind & B_BUFFER_CONSUMER) == 0) 1793 return B_MEDIA_BAD_NODE; 1794 if (out_active_inputs == NULL || out_total_count == NULL) 1795 return B_BAD_VALUE; 1796 1797 List<media_input> list; 1798 media_input *input; 1799 status_t rv; 1800 1801 *out_total_count = 0; 1802 1803 rv = MediaRosterEx(this)->GetAllInputs(node, &list); 1804 if (B_OK != rv) 1805 return rv; 1806 1807 PRINT(4, "BMediaRoster::GetConnectedInputsFor node %" B_PRId32 ", max %" 1808 B_PRId32 "\n", node.node, buf_num_inputs); 1809 1810 int32 i; 1811 for (i = 0, list.Rewind(); list.GetNext(&input);) { 1812 if (input->source == media_source::null) 1813 continue; // consumer source not connected 1814 out_active_inputs[i] = *input; 1815 *out_total_count += 1; 1816 buf_num_inputs -= 1; 1817 #if DEBUG >= 3 1818 PRINT_OUTPUT(" input ", out_active_inputs[i]); 1819 #endif 1820 if (buf_num_inputs == 0) 1821 break; 1822 i++; 1823 } 1824 1825 MediaRosterEx(this)->PublishInputs(node, &list); 1826 return B_OK; 1827} 1828 1829 1830status_t 1831BMediaRoster::GetAllInputsFor(const media_node& node, media_input* out_inputs, 1832 int32 buf_num_inputs, int32* out_total_count) 1833{ 1834 CALLED(); 1835 if (IS_INVALID_NODE(node) || (node.kind & B_BUFFER_CONSUMER) == 0) 1836 return B_MEDIA_BAD_NODE; 1837 if (out_inputs == NULL || out_total_count == NULL) 1838 return B_BAD_VALUE; 1839 1840 List<media_input> list; 1841 media_input *input; 1842 status_t rv; 1843 1844 *out_total_count = 0; 1845 1846 rv = MediaRosterEx(this)->GetAllInputs(node, &list); 1847 if (B_OK != rv) 1848 return rv; 1849 1850 PRINT(4, "BMediaRoster::GetAllInputsFor node %" B_PRId32 ", max %" B_PRId32 1851 "\n", node.node, buf_num_inputs); 1852 1853 int32 i; 1854 for (i = 0, list.Rewind(); list.GetNext(&input); i++) { 1855 out_inputs[i] = *input; 1856 *out_total_count += 1; 1857 buf_num_inputs -= 1; 1858 #if DEBUG >= 3 1859 PRINT_OUTPUT(" input ", out_inputs[i]); 1860 #endif 1861 if (buf_num_inputs == 0) 1862 break; 1863 } 1864 1865 MediaRosterEx(this)->PublishInputs(node, &list); 1866 return B_OK; 1867} 1868 1869 1870status_t 1871BMediaRoster::GetFreeOutputsFor(const media_node& node, 1872 media_output* out_free_outputs, int32 buf_num_outputs, 1873 int32* out_total_count, media_type filter_type) 1874{ 1875 CALLED(); 1876 if (IS_INVALID_NODE(node) || (node.kind & B_BUFFER_PRODUCER) == 0) 1877 return B_MEDIA_BAD_NODE; 1878 if (out_free_outputs == NULL || out_total_count == NULL) 1879 return B_BAD_VALUE; 1880 1881 List<media_output> list; 1882 media_output *output; 1883 status_t rv; 1884 1885 *out_total_count = 0; 1886 1887 rv = MediaRosterEx(this)->GetAllOutputs(node, &list); 1888 if (B_OK != rv) 1889 return rv; 1890 1891 PRINT(4, "BMediaRoster::GetFreeOutputsFor node %" B_PRId32 ", max %" 1892 B_PRId32 ", filter-type %" B_PRId32 "\n", node.node, buf_num_outputs, 1893 filter_type); 1894 1895 int32 i; 1896 for (i = 0, list.Rewind(); list.GetNext(&output);) { 1897 if (filter_type != B_MEDIA_UNKNOWN_TYPE 1898 && filter_type != output->format.type) { 1899 // media_type used, but doesn't match 1900 continue; 1901 } 1902 if (output->destination != media_destination::null) { 1903 // producer destination already connected 1904 continue; 1905 } 1906 1907 out_free_outputs[i] = *output; 1908 *out_total_count += 1; 1909 buf_num_outputs -= 1; 1910 #if DEBUG >= 3 1911 PRINT_OUTPUT(" output ", out_free_outputs[i]); 1912 #endif 1913 if (buf_num_outputs == 0) 1914 break; 1915 i++; 1916 } 1917 1918 MediaRosterEx(this)->PublishOutputs(node, &list); 1919 return B_OK; 1920} 1921 1922 1923status_t 1924BMediaRoster::GetConnectedOutputsFor(const media_node& node, 1925 media_output* out_active_outputs, int32 buf_num_outputs, 1926 int32* out_total_count) 1927{ 1928 CALLED(); 1929 if (IS_INVALID_NODE(node) || (node.kind & B_BUFFER_PRODUCER) == 0) 1930 return B_MEDIA_BAD_NODE; 1931 if (out_active_outputs == NULL || out_total_count == NULL) 1932 return B_BAD_VALUE; 1933 1934 List<media_output> list; 1935 media_output *output; 1936 status_t rv; 1937 1938 *out_total_count = 0; 1939 1940 rv = MediaRosterEx(this)->GetAllOutputs(node, &list); 1941 if (B_OK != rv) 1942 return rv; 1943 1944 PRINT(4, "BMediaRoster::GetConnectedOutputsFor node %" B_PRId32 ", max %" 1945 B_PRId32 "\n", node.node, buf_num_outputs); 1946 1947 int32 i; 1948 for (i = 0, list.Rewind(); list.GetNext(&output);) { 1949 if (output->destination == media_destination::null) { 1950 // producer destination not connected 1951 continue; 1952 } 1953 out_active_outputs[i] = *output; 1954 *out_total_count += 1; 1955 buf_num_outputs -= 1; 1956 #if DEBUG >= 3 1957 PRINT_OUTPUT(" output ", out_active_outputs[i]); 1958 #endif 1959 if (buf_num_outputs == 0) 1960 break; 1961 i++; 1962 } 1963 1964 MediaRosterEx(this)->PublishOutputs(node, &list); 1965 return B_OK; 1966} 1967 1968 1969status_t 1970BMediaRoster::GetAllOutputsFor(const media_node& node, 1971 media_output* out_outputs, int32 buf_num_outputs, int32* out_total_count) 1972{ 1973 CALLED(); 1974 if (IS_INVALID_NODE(node) || (node.kind & B_BUFFER_PRODUCER) == 0) 1975 return B_MEDIA_BAD_NODE; 1976 if (out_outputs == NULL || out_total_count == NULL) 1977 return B_BAD_VALUE; 1978 1979 List<media_output> list; 1980 media_output *output; 1981 status_t rv; 1982 1983 *out_total_count = 0; 1984 1985 rv = MediaRosterEx(this)->GetAllOutputs(node, &list); 1986 if (B_OK != rv) 1987 return rv; 1988 1989 PRINT(4, "BMediaRoster::GetAllOutputsFor node %" B_PRId32 ", max %" B_PRId32 1990 "\n", node.node, buf_num_outputs); 1991 1992 int32 i; 1993 for (i = 0, list.Rewind(); list.GetNext(&output); i++) { 1994 out_outputs[i] = *output; 1995 *out_total_count += 1; 1996 buf_num_outputs -= 1; 1997 #if DEBUG >= 3 1998 PRINT_OUTPUT(" output ", out_outputs[i]); 1999 #endif 2000 if (buf_num_outputs == 0) 2001 break; 2002 } 2003 2004 MediaRosterEx(this)->PublishOutputs(node, &list); 2005 return B_OK; 2006} 2007 2008 2009status_t 2010BMediaRoster::StartWatching(const BMessenger& where) 2011{ 2012 CALLED(); 2013 if (!where.IsValid()) { 2014 ERROR("BMediaRoster::StartWatching: messenger invalid!\n"); 2015 return B_BAD_VALUE; 2016 } 2017 return BPrivate::media::notifications::Register(where, media_node::null, 2018 B_MEDIA_WILDCARD); 2019} 2020 2021 2022status_t 2023BMediaRoster::StartWatching(const BMessenger & where, int32 notificationType) 2024{ 2025 CALLED(); 2026 if (!where.IsValid()) { 2027 ERROR("BMediaRoster::StartWatching: messenger invalid!\n"); 2028 return B_BAD_VALUE; 2029 } 2030 if (!BPrivate::media::notifications::IsValidNotificationRequest(false, 2031 notificationType)) { 2032 ERROR("BMediaRoster::StartWatching: notificationType invalid!\n"); 2033 return B_BAD_VALUE; 2034 } 2035 2036 // NOTE: we support only explicitly B_MEDIA_SERVER_STARTED/QUIT 2037 // notifications. This should be cleared in documentation. 2038 2039 return BPrivate::media::notifications::Register(where, media_node::null, 2040 notificationType); 2041} 2042 2043 2044status_t 2045BMediaRoster::StartWatching(const BMessenger& where, const media_node& node, 2046 int32 notificationType) 2047{ 2048 CALLED(); 2049 if (!where.IsValid()) { 2050 ERROR("BMediaRoster::StartWatching: messenger invalid!\n"); 2051 return B_BAD_VALUE; 2052 } 2053 if (IS_INVALID_NODE(node)) { 2054 ERROR("BMediaRoster::StartWatching: node invalid!\n"); 2055 return B_MEDIA_BAD_NODE; 2056 } 2057 if (!BPrivate::media::notifications::IsValidNotificationRequest(true, 2058 notificationType)) { 2059 ERROR("BMediaRoster::StartWatching: notificationType invalid!\n"); 2060 return B_BAD_VALUE; 2061 } 2062 return BPrivate::media::notifications::Register(where, node, 2063 notificationType); 2064} 2065 2066 2067status_t 2068BMediaRoster::StopWatching(const BMessenger& where) 2069{ 2070 CALLED(); 2071 // messenger may already be invalid, so we don't check this 2072 return BPrivate::media::notifications::Unregister(where, media_node::null, 2073 B_MEDIA_WILDCARD); 2074} 2075 2076 2077status_t 2078BMediaRoster::StopWatching(const BMessenger& where, int32 notificationType) 2079{ 2080 CALLED(); 2081 // messenger may already be invalid, so we don't check this 2082 if (!BPrivate::media::notifications::IsValidNotificationRequest(false, 2083 notificationType)) { 2084 ERROR("BMediaRoster::StopWatching: notificationType invalid!\n"); 2085 return B_BAD_VALUE; 2086 } 2087 return BPrivate::media::notifications::Unregister(where, media_node::null, 2088 notificationType); 2089} 2090 2091 2092status_t 2093BMediaRoster::StopWatching(const BMessenger& where, const media_node& node, 2094 int32 notificationType) 2095{ 2096 CALLED(); 2097 // messenger may already be invalid, so we don't check this 2098 if (IS_INVALID_NODE(node)) { 2099 ERROR("BMediaRoster::StopWatching: node invalid!\n"); 2100 return B_MEDIA_BAD_NODE; 2101 } 2102 if (!BPrivate::media::notifications::IsValidNotificationRequest(true, 2103 notificationType)) { 2104 ERROR("BMediaRoster::StopWatching: notificationType invalid!\n"); 2105 return B_BAD_VALUE; 2106 } 2107 return BPrivate::media::notifications::Unregister(where, node, 2108 notificationType); 2109} 2110 2111 2112status_t 2113BMediaRoster::RegisterNode(BMediaNode* node) 2114{ 2115 CALLED(); 2116 // addon-id = -1 (unused), addon-flavor-id = 0 (unused, too) 2117 return MediaRosterEx(this)->RegisterNode(node, -1, 0); 2118} 2119 2120 2121status_t 2122BMediaRosterEx::RegisterNode(BMediaNode* node, media_addon_id addOnID, 2123 int32 flavorID) 2124{ 2125 CALLED(); 2126 if (node == NULL) 2127 return B_BAD_VALUE; 2128 2129 // some sanity check 2130 // I'm not sure if the media kit warrants to call BMediaNode::AddOn() here. 2131 // Perhaps we don't need it. 2132 DEBUG_ONLY( 2133 int32 testFlavorID; 2134 BMediaAddOn* addon = node->AddOn(&testFlavorID); 2135 2136 ASSERT(addOnID == (addon != NULL ? addon->AddonID() : -1)); 2137// ASSERT(flavorID == testFlavorID); 2138 ); 2139 2140 server_register_node_request request; 2141 server_register_node_reply reply; 2142 2143 request.add_on_id = addOnID; 2144 request.flavor_id = flavorID; 2145 strcpy(request.name, node->Name()); 2146 request.kinds = node->Kinds(); 2147 request.port = node->ControlPort(); 2148 request.team = BPrivate::current_team(); 2149 request.timesource_id = node->fTimeSourceID; 2150 2151 TRACE("BMediaRoster::RegisterNode: sending SERVER_REGISTER_NODE: port " 2152 "%" B_PRId32 ", kinds 0x%" B_PRIx64 ", team %" B_PRId32 ", name '%s'\n", 2153 request.port, request.kinds, request.team, request.name); 2154 2155 status_t status = QueryServer(SERVER_REGISTER_NODE, &request, 2156 sizeof(request), &reply, sizeof(reply)); 2157 if (status != B_OK) { 2158 ERROR("BMediaRoster::RegisterNode: failed to register node %s: %s\n", 2159 node->Name(), strerror(status)); 2160 return status; 2161 } 2162 2163 TRACE("BMediaRoster::RegisterNode: QueryServer SERVER_REGISTER_NODE " 2164 "finished\n"); 2165 2166 // we are a friend class of BMediaNode and initialize this member variable 2167 node->fNodeID = reply.node_id; 2168 ASSERT(reply.node_id == node->Node().node); 2169 ASSERT(reply.node_id == node->ID()); 2170 2171 // if the BMediaNode also inherits from BTimeSource, we need to call 2172 // BTimeSource::FinishCreate() 2173 if ((node->Kinds() & B_TIME_SOURCE) != 0) { 2174 if (BTimeSource* timeSource = dynamic_cast<BTimeSource*>(node)) 2175 timeSource->FinishCreate(); 2176 } 2177 2178 // call the callback 2179 node->NodeRegistered(); 2180 2181 TRACE("BMediaRoster::RegisterNode: NodeRegistered callback finished\n"); 2182 2183 TRACE("BMediaRoster::RegisterNode: publishing inputs/outputs\n"); 2184 2185 // register existing inputs and outputs with the 2186 // media_server, this allows GetLiveNodes() to work 2187 // with created, but unconnected nodes. 2188 // The node control loop might not be running, or might deadlock 2189 // if we send a message and wait for a reply here. 2190 // We have a pointer to the node, and thus call the functions directly 2191 2192 if ((node->Kinds() & B_BUFFER_PRODUCER) != 0) { 2193 if (BBufferProducer* producer = dynamic_cast<BBufferProducer*>(node)) { 2194 List<media_output> list; 2195 if (GetAllOutputs(producer, &list) == B_OK) 2196 PublishOutputs(node->Node(), &list); 2197 } 2198 } 2199 if ((node->Kinds() & B_BUFFER_CONSUMER) != 0) { 2200 if (BBufferConsumer* consumer = dynamic_cast<BBufferConsumer*>(node)) { 2201 List<media_input> list; 2202 if (GetAllInputs(consumer, &list) == B_OK) 2203 PublishInputs(node->Node(), &list); 2204 } 2205 } 2206 2207 TRACE("BMediaRoster::RegisterNode: sending NodesCreated\n"); 2208 2209 BPrivate::media::notifications::NodesCreated(&reply.node_id, 1); 2210 2211 TRACE("BMediaRoster::RegisterNode: finished\n"); 2212 2213/* 2214 TRACE("BMediaRoster::RegisterNode: registered node name '%s', id %ld, 2215 addon %ld, flavor %ld\n", node->Name(), node->ID(), addOnID, flavorID); 2216 TRACE("BMediaRoster::RegisterNode: node this %p\n", node); 2217 TRACE("BMediaRoster::RegisterNode: node fConsumerThis %p\n", 2218 node->fConsumerThis); 2219 TRACE("BMediaRoster::RegisterNode: node fProducerThis %p\n", 2220 node->fProducerThis); 2221 TRACE("BMediaRoster::RegisterNode: node fFileInterfaceThis %p\n", 2222 node->fFileInterfaceThis); 2223 TRACE("BMediaRoster::RegisterNode: node fControllableThis %p\n", 2224 node->fControllableThis); 2225 TRACE("BMediaRoster::RegisterNode: node fTimeSourceThis %p\n", 2226 node->fTimeSourceThis); 2227*/ 2228 return B_OK; 2229} 2230 2231 2232status_t 2233BMediaRoster::UnregisterNode(BMediaNode* node) 2234{ 2235 CALLED(); 2236 if (node == NULL) 2237 return B_BAD_VALUE; 2238 2239 TRACE("BMediaRoster::UnregisterNode %" 2240 B_PRId32 " (%p)\n", node->ID(), node); 2241 2242 if ((node->fKinds & NODE_KIND_NO_REFCOUNTING) !=0) { 2243 TRACE("BMediaRoster::UnregisterNode, trying to unregister reference " 2244 "counting disabled timesource, node %" 2245 B_PRId32 " , port %" B_PRId32 " , team %" B_PRId32 "\n", 2246 node->ID(), node->ControlPort(), BPrivate::current_team()); 2247 return B_OK; 2248 } 2249 if (node->ID() == NODE_UNREGISTERED_ID) { 2250 PRINT(1, "Warning: BMediaRoster::UnregisterNode: node id %" B_PRId32 2251 ", name '%s' already unregistered\n", node->ID(), node->Name()); 2252 return B_OK; 2253 } 2254 if (node->fRefCount != 0) { 2255 PRINT(1, "Warning: BMediaRoster::UnregisterNode: node id %" B_PRId32 2256 ", name '%s' has local reference count of %" B_PRId32 "\n", 2257 node->ID(), node->Name(), node->fRefCount); 2258 // no return here, we continue and unregister! 2259 } 2260 2261 // Calling BMediaAddOn::GetConfigurationFor(BMediaNode *node, 2262 // BMessage *config) if this node was instanciated by an add-on needs to 2263 // be done *somewhere* 2264 // We can't do it here because it is already to late (destructor of the node 2265 // might have been called). 2266 2267 server_unregister_node_request request; 2268 request.node_id = node->ID(); 2269 request.team = BPrivate::current_team(); 2270 2271 // send a notification 2272 BPrivate::media::notifications::NodesDeleted(&request.node_id, 1); 2273 2274 server_unregister_node_reply reply; 2275 reply.add_on_id = -1; 2276 status_t status = QueryServer(SERVER_UNREGISTER_NODE, &request, 2277 sizeof(request), &reply, sizeof(reply)); 2278 if (status != B_OK) { 2279 ERROR("BMediaRoster::UnregisterNode: failed to unregister node id %" 2280 B_PRId32 ", name '%s': %s\n", node->ID(), node->Name(), 2281 strerror(status)); 2282 BMediaAddOn *addon = node->AddOn(&reply.flavor_id); 2283 if (addon != NULL) 2284 reply.add_on_id = addon->AddonID(); 2285 } 2286 2287 if (reply.add_on_id != -1) { 2288 // TODO: this doesn't look right 2289 // Small problem here, we can't use DormantNodeManager::PutAddOn(), as 2290 // UnregisterNode() is called by a dormant node itself (by the 2291 // destructor). 2292 // The add-on that contains the node needs to remain in memory until the 2293 // destructor execution is finished. 2294 // DormantNodeManager::PutAddOnDelayed() will delay unloading. 2295 gDormantNodeManager->PutAddOnDelayed(reply.add_on_id); 2296 2297 status = MediaRosterEx(this)->DecrementAddonFlavorInstancesCount( 2298 reply.add_on_id, reply.flavor_id); 2299 if (status != B_OK) { 2300 ERROR("BMediaRoster::UnregisterNode: " 2301 "DecrementAddonFlavorInstancesCount() failed\n"); 2302 // this is really a problem, but we can't fail now 2303 } 2304 } 2305 2306 // we are a friend class of BMediaNode and invalidate this member variable 2307 node->fNodeID = NODE_UNREGISTERED_ID; 2308 2309 return status; 2310} 2311 2312 2313//! Thread safe for multiple calls to Roster() 2314/*static*/ BMediaRoster* 2315BMediaRoster::Roster(status_t* out_error) 2316{ 2317 BAutolock lock(sInitLocker); 2318 2319 if (be_app == NULL) 2320 TRACE("Warning! You should have a valid BApplication."); 2321 2322 if (!lock.IsLocked()) 2323 return NULL; 2324 2325 if (out_error) 2326 *out_error = B_OK; 2327 2328 if (sDefaultInstance == NULL) { 2329 status_t err; 2330 sDefaultInstance = new (std::nothrow) BMediaRosterEx(&err); 2331 if (sDefaultInstance == NULL) 2332 err = B_NO_MEMORY; 2333 else if (err != B_OK) { 2334 if (sDefaultInstance) { 2335 sDefaultInstance->Lock(); 2336 sDefaultInstance->Quit(); 2337 sDefaultInstance = NULL; 2338 } 2339 if (out_error) 2340 *out_error = err; 2341 } else if (be_app != NULL) { 2342 be_app->RegisterLooper(sDefaultInstance); 2343 } 2344 } 2345 2346 return sDefaultInstance; 2347} 2348 2349 2350/*static*/ BMediaRoster* 2351BMediaRoster::CurrentRoster() 2352{ 2353 return sDefaultInstance; 2354} 2355 2356 2357status_t 2358BMediaRoster::SetTimeSourceFor(media_node_id node, media_node_id time_source) 2359{ 2360 CALLED(); 2361 if (IS_INVALID_NODEID(node) || IS_INVALID_NODEID(time_source)) 2362 return B_BAD_VALUE; 2363 2364 media_node clone; 2365 // We need to get a clone of the node to have a port id 2366 status_t result = GetNodeFor(node, &clone); 2367 if (result == B_OK) { 2368 // We just send the request to set time_source-id as 2369 // timesource to the node, the NODE_SET_TIMESOURCE handler 2370 // code will do the real assignment. 2371 result = B_OK; 2372 node_set_timesource_command cmd; 2373 cmd.timesource_id = time_source; 2374 result = SendToPort(clone.port, NODE_SET_TIMESOURCE, 2375 &cmd, sizeof(cmd)); 2376 if (result != B_OK) { 2377 ERROR("BMediaRoster::SetTimeSourceFor" 2378 "sending NODE_SET_TIMESOURCE failed, node id %" 2379 B_PRId32 "\n", clone.node); 2380 } 2381 // We release the clone 2382 result = ReleaseNode(clone); 2383 if (result != B_OK) { 2384 ERROR("BMediaRoster::SetTimeSourceFor, ReleaseNode failed," 2385 " node id %" B_PRId32 "\n", clone.node); 2386 } 2387 } else { 2388 ERROR("BMediaRoster::SetTimeSourceFor GetCloneForID failed, " 2389 "node id %" B_PRId32 "\n", node); 2390 } 2391 2392 if (result == B_OK) { 2393 // Notify the server 2394 server_set_node_timesource_request request; 2395 server_set_node_timesource_reply reply; 2396 2397 request.node_id = node; 2398 request.timesource_id = time_source; 2399 2400 result = QueryServer(SERVER_SET_NODE_TIMESOURCE, &request, 2401 sizeof(request), &reply, sizeof(reply)); 2402 if (result != B_OK) { 2403 ERROR("BMediaRoster::SetTimeSourceFor, sending NODE_SET_TIMESOURCE " 2404 "failed, node id %" B_PRId32 "\n", node); 2405 } else { 2406 TRACE("BMediaRoster::SetTimeSourceFor: node %" B_PRId32 " time source %" 2407 B_PRId32 " OK\n", node, time_source); 2408 } 2409 } 2410 return result; 2411} 2412 2413 2414status_t 2415BMediaRoster::GetParameterWebFor(const media_node& node, BParameterWeb** _web) 2416{ 2417 CALLED(); 2418 if (_web == NULL) 2419 return B_BAD_VALUE; 2420 if (IS_INVALID_NODE(node)) 2421 return B_MEDIA_BAD_NODE; 2422 if ((node.kind & B_CONTROLLABLE) == 0) 2423 return B_MEDIA_BAD_NODE; 2424 2425 controllable_get_parameter_web_request request; 2426 controllable_get_parameter_web_reply reply; 2427 int32 requestsize[] = {B_PAGE_SIZE, 4 * B_PAGE_SIZE, 16 * B_PAGE_SIZE, 2428 64 * B_PAGE_SIZE, 128 * B_PAGE_SIZE, 256 * B_PAGE_SIZE, 0}; 2429 int32 size; 2430 2431 // TODO: it might be better to query the node for the (current) parameter 2432 // size first 2433 for (int i = 0; (size = requestsize[i]) != 0; i++) { 2434 status_t rv; 2435 area_id area; 2436 void *data; 2437 area = create_area("parameter web data", &data, B_ANY_ADDRESS, size, 2438 B_NO_LOCK, B_READ_AREA | B_WRITE_AREA | B_CLONEABLE_AREA); 2439 if (area < B_OK) { 2440 ERROR("BMediaRoster::GetParameterWebFor couldn't create area of " 2441 "size %" B_PRId32 "\n", size); 2442 return B_ERROR; 2443 } 2444 request.max_size = size; 2445 request.area = area; 2446 rv = QueryPort(node.port, CONTROLLABLE_GET_PARAMETER_WEB, &request, 2447 sizeof(request), &reply, sizeof(reply)); 2448 if (rv != B_OK) { 2449 ERROR("BMediaRoster::GetParameterWebFor " 2450 "CONTROLLABLE_GET_PARAMETER_WEB failed\n"); 2451 delete_area(area); 2452 return B_ERROR; 2453 } 2454 if (reply.size == 0) { 2455 // no parameter web available 2456 // TODO: should we return an error? 2457 ERROR("BMediaRoster::GetParameterWebFor node %" B_PRId32 2458 " has no parameter web\n", node.node); 2459 *_web = new (std::nothrow) BParameterWeb(); 2460 delete_area(area); 2461 return *_web != NULL ? B_OK : B_NO_MEMORY; 2462 } 2463 if (reply.size > 0) { 2464 // we got a flattened parameter web! 2465 BParameterWeb* web = new (std::nothrow) BParameterWeb(); 2466 if (web == NULL) 2467 rv = B_NO_MEMORY; 2468 else { 2469 rv = web->Unflatten(reply.code, data, reply.size); 2470 if (rv != B_OK) { 2471 ERROR("BMediaRoster::GetParameterWebFor Unflatten failed, " 2472 "%s\n", strerror(rv)); 2473 delete web; 2474 } else 2475 *_web = web; 2476 } 2477 2478 delete_area(area); 2479 return rv; 2480 } 2481 delete_area(area); 2482 ASSERT(reply.size == -1); 2483 // parameter web data was too large 2484 // loop and try a larger size 2485 } 2486 ERROR("BMediaRoster::GetParameterWebFor node %" B_PRId32 " has no " 2487 "parameter web larger than %" B_PRId32 "\n", node.node, size); 2488 return B_ERROR; 2489} 2490 2491 2492status_t 2493BMediaRoster::StartControlPanel(const media_node& node, BMessenger* _messenger) 2494{ 2495 CALLED(); 2496 2497 controllable_start_control_panel_request request; 2498 controllable_start_control_panel_reply reply; 2499 2500 request.node = node; 2501 2502 status_t rv; 2503 rv = QueryPort(node.port, CONTROLLABLE_START_CONTROL_PANEL, &request, 2504 sizeof(request), &reply, sizeof(reply)); 2505 if (rv != B_OK) 2506 return rv; 2507 2508 if (reply.team != -1 && _messenger != NULL) 2509 *_messenger = BMessenger(NULL, reply.team); 2510 2511 return B_OK; 2512} 2513 2514 2515status_t 2516BMediaRoster::GetDormantNodes(dormant_node_info* _info, int32* _count, 2517 const media_format* hasInput, const media_format* hasOutput, 2518 const char* name, uint64 requireKinds, uint64 denyKinds) 2519{ 2520 CALLED(); 2521 if (_info == NULL || _count == NULL || *_count <= 0) 2522 return B_BAD_VALUE; 2523 2524 server_get_dormant_nodes_request request; 2525 request.max_count = *_count; 2526 request.has_input = hasInput != NULL; 2527 if (hasInput != NULL) { 2528 // TODO: we should not make a flat copy of media_format 2529 request.input_format = *hasInput; 2530 } 2531 request.has_output = hasOutput != NULL; 2532 if (hasOutput != NULL) { 2533 // TODO: we should not make a flat copy of media_format 2534 request.output_format = *hasOutput; 2535 } 2536 2537 request.has_name = name != NULL; 2538 if (name != NULL) 2539 strlcpy(request.name, name, sizeof(request.name)); 2540 2541 request.require_kinds = requireKinds; 2542 request.deny_kinds = denyKinds; 2543 2544 server_get_dormant_nodes_reply reply; 2545 status_t status = QueryServer(SERVER_GET_DORMANT_NODES, &request, 2546 sizeof(request), &reply, sizeof(reply)); 2547 if (status != B_OK) 2548 return status; 2549 2550 *_count = reply.count; 2551 2552 if (reply.count > 0) { 2553 int32 code; 2554 status = read_port(request.reply_port, &code, _info, 2555 reply.count * sizeof(dormant_node_info)); 2556 if (status < B_OK) 2557 reply.result = status; 2558 } 2559 2560 return reply.result; 2561} 2562 2563 2564/*! This function is used to do the real work of instantiating a dormant node. 2565 It is either called by the media_addon_server to instantiate a global node, 2566 or it gets called from BMediaRoster::InstantiateDormantNode() to create a 2567 local one. 2568 2569 Checks concerning global/local are not done here. 2570*/ 2571status_t 2572BMediaRosterEx::InstantiateDormantNode(media_addon_id addonID, int32 flavorID, 2573 team_id creator, media_node *_node) 2574{ 2575 // This function is always called from the correct context, if the node 2576 // is supposed to be global, it is called from the media_addon_server. 2577 2578 // if B_FLAVOR_IS_GLOBAL, we need to use the BMediaAddOn object that 2579 // resides in the media_addon_server 2580 2581 // RegisterNode() must be called for nodes instantiated from add-ons, 2582 // since the media kit warrants that it's done automatically. 2583 2584 // addonID Indicates the ID number of the media add-on in which the 2585 // node resides. 2586 // flavorID Indicates the internal ID number that the add-on uses to 2587 // identify the flavor, this is the number that was published 2588 // by BMediaAddOn::GetFlavorAt() in the 2589 // flavor_info::internal_id field. 2590 // creator The creator team is -1 if nodes are created locally. If 2591 // created globally, it will contain (while called in 2592 // media_addon_server context) the team-id of the team that 2593 // requested the instantiation. 2594 2595 TRACE("BMediaRosterEx::InstantiateDormantNode: addonID %" B_PRId32 2596 ", flavorID %" B_PRId32 "\n", addonID, flavorID); 2597 2598 // Get flavor_info from the server 2599 dormant_flavor_info info; 2600 status_t rv; 2601 rv = GetDormantFlavorInfo(addonID, flavorID, &info); 2602 if (rv != B_OK) { 2603 ERROR("BMediaRosterEx::InstantiateDormantNode error: failed to get " 2604 "dormant_flavor_info for addon-id %" B_PRId32 ", flavor-id %" 2605 B_PRId32 "\n", addonID, flavorID); 2606 return B_ERROR; 2607 } 2608 2609 ASSERT(info.internal_id == flavorID); 2610 2611 // load the BMediaAddOn object 2612 BMediaAddOn* addon = gDormantNodeManager->GetAddOn(addonID); 2613 if (addon == NULL) { 2614 ERROR("BMediaRosterEx::InstantiateDormantNode: GetAddon failed\n"); 2615 return B_ERROR; 2616 } 2617 2618 // Now we need to try to increment the use count of this addon flavor 2619 // in the server. This can fail if the total number instances of this 2620 // flavor is limited. 2621 rv = IncrementAddonFlavorInstancesCount(addonID, flavorID); 2622 if (rv != B_OK) { 2623 ERROR("BMediaRosterEx::InstantiateDormantNode error: can't create " 2624 "more nodes for addon-id %" B_PRId32 ", flavor-id %" B_PRId32 "\n", 2625 addonID, flavorID); 2626 // Put the addon back into the pool 2627 gDormantNodeManager->PutAddOn(addonID); 2628 return B_ERROR; 2629 } 2630 2631 BMessage config; 2632 rv = LoadNodeConfiguration(addonID, flavorID, &config); 2633 if (rv != B_OK) { 2634 ERROR("BMediaRosterEx::InstantiateDormantNode: couldn't load " 2635 "configuration for addon-id %" B_PRId32 ", flavor-id %" B_PRId32 2636 "\n", addonID, flavorID); 2637 // do not return, this is a minor problem, not a reason to fail 2638 } 2639 2640 status_t status = B_OK; 2641 BMediaNode* node = addon->InstantiateNodeFor(&info, &config, &status); 2642 if (node == NULL) { 2643 ERROR("BMediaRosterEx::InstantiateDormantNode: InstantiateNodeFor " 2644 "failed\n"); 2645 2646 // Put the addon back into the pool 2647 gDormantNodeManager->PutAddOn(addonID); 2648 2649 // We must decrement the use count of this addon flavor in the 2650 // server to compensate the increment done in the beginning. 2651 rv = DecrementAddonFlavorInstancesCount(addonID, flavorID); 2652 if (rv != B_OK) { 2653 ERROR("BMediaRosterEx::InstantiateDormantNode: DecrementAddon" 2654 "FlavorInstancesCount failed\n"); 2655 } 2656 return status != B_OK ? status : B_ERROR; 2657 } 2658 2659 rv = RegisterNode(node, addonID, flavorID); 2660 if (rv != B_OK) { 2661 ERROR("BMediaRosterEx::InstantiateDormantNode: RegisterNode failed\n"); 2662 delete node; 2663 // Put the addon back into the pool 2664 gDormantNodeManager->PutAddOn(addonID); 2665 // We must decrement the use count of this addon flavor in the 2666 // server to compensate the increment done in the beginning. 2667 rv = DecrementAddonFlavorInstancesCount(addonID, flavorID); 2668 if (rv != B_OK) { 2669 ERROR("BMediaRosterEx::InstantiateDormantNode: DecrementAddon" 2670 "FlavorInstancesCount failed\n"); 2671 } 2672 return B_ERROR; 2673 } 2674 2675 if (creator != -1) { 2676 // send a message to the server to assign team "creator" as creator 2677 // of node "node->ID()" 2678 printf("!!! BMediaRosterEx::InstantiateDormantNode assigning team %" 2679 B_PRId32 " as creator of node %" B_PRId32 "\n", creator, 2680 node->ID()); 2681 2682 rv = MediaRosterEx(this)->SetNodeCreator(node->ID(), creator); 2683 if (rv != B_OK) { 2684 ERROR("BMediaRosterEx::InstantiateDormantNode failed to assign " 2685 "team %" B_PRId32 " as creator of node %" B_PRId32 "\n", 2686 creator, node->ID()); 2687 // do not return, this is a minor problem, not a reason to fail 2688 } 2689 } 2690 2691 // RegisterNode() does remember the add-on id in the server 2692 // and UnregisterNode() will call DormantNodeManager::PutAddon() 2693 // when the node is unregistered. 2694 2695 *_node = node->Node(); 2696 2697 TRACE("BMediaRosterEx::InstantiateDormantNode: addon-id %" B_PRId32 2698 ", flavor_id %" B_PRId32 " instanciated as node %" B_PRId32 ", port %" 2699 B_PRId32 " in team %" B_PRId32 "\n", addonID, flavorID, _node->node, 2700 _node->port, BPrivate::current_team()); 2701 2702 return B_OK; 2703} 2704 2705 2706status_t 2707BMediaRoster::InstantiateDormantNode(const dormant_node_info& info, 2708 media_node* _node, uint32 flags) 2709{ 2710 CALLED(); 2711 if (_node == NULL) 2712 return B_BAD_VALUE; 2713 if (info.addon <= B_OK) { 2714 ERROR("BMediaRoster::InstantiateDormantNode error: addon-id %" B_PRId32 2715 " invalid.\n", info.addon); 2716 return B_BAD_VALUE; 2717 } 2718 2719 printf("BMediaRoster::InstantiateDormantNode: addon-id %" B_PRId32 2720 ", flavor_id %" B_PRId32 ", flags 0x%" B_PRIx32 "\n", info.addon, 2721 info.flavor_id, flags); 2722 2723 // Get flavor_info from the server 2724 // TODO: this is a little overhead, as we get the full blown 2725 // dormant_flavor_info, 2726 // TODO: but only need the flags. 2727 dormant_flavor_info flavorInfo; 2728 status_t rv; 2729 rv = MediaRosterEx(this)->GetDormantFlavorInfo(info.addon, info.flavor_id, 2730 &flavorInfo); 2731 if (rv != B_OK) { 2732 ERROR("BMediaRoster::InstantiateDormantNode: failed to get " 2733 "dormant_flavor_info for addon-id %" B_PRId32 ", flavor-id %" 2734 B_PRId32 "\n", info.addon, info.flavor_id); 2735 return B_NAME_NOT_FOUND; 2736 } 2737 2738 ASSERT(flavorInfo.internal_id == info.flavor_id); 2739 2740#if DEBUG 2741 printf("BMediaRoster::InstantiateDormantNode: name \"%s\", info \"%s\", " 2742 "flavor_flags 0x%" B_PRIx32 ", internal_id %" B_PRId32 2743 ", possible_count %" B_PRId32 "\n", flavorInfo.name, flavorInfo.info, 2744 flavorInfo.flavor_flags, flavorInfo.internal_id, 2745 flavorInfo.possible_count); 2746 2747 if ((flags & B_FLAVOR_IS_LOCAL) != 0) { 2748 printf("BMediaRoster::InstantiateDormantNode: caller requested " 2749 "B_FLAVOR_IS_LOCAL\n"); 2750 } 2751 if ((flags & B_FLAVOR_IS_GLOBAL) != 0) { 2752 printf("BMediaRoster::InstantiateDormantNode: caller requested " 2753 "B_FLAVOR_IS_GLOBAL\n"); 2754 } 2755 if ((flavorInfo.flavor_flags & B_FLAVOR_IS_LOCAL) != 0) { 2756 printf("BMediaRoster::InstantiateDormantNode: node requires " 2757 "B_FLAVOR_IS_LOCAL\n"); 2758 } 2759 if ((flavorInfo.flavor_flags & B_FLAVOR_IS_GLOBAL) != 0) { 2760 printf("BMediaRoster::InstantiateDormantNode: node requires " 2761 "B_FLAVOR_IS_GLOBAL\n"); 2762 } 2763#endif 2764 2765 // Make sure that flags demanded by the dormant node and those requested 2766 // by the caller are not incompatible. 2767 if ((flavorInfo.flavor_flags & B_FLAVOR_IS_GLOBAL) != 0 2768 && (flags & B_FLAVOR_IS_LOCAL) != 0) { 2769 ERROR("BMediaRoster::InstantiateDormantNode: requested " 2770 "B_FLAVOR_IS_LOCAL, but dormant node has B_FLAVOR_IS_GLOBAL\n"); 2771 return B_NAME_NOT_FOUND; 2772 } 2773 if ((flavorInfo.flavor_flags & B_FLAVOR_IS_LOCAL) != 0 2774 && (flags & B_FLAVOR_IS_GLOBAL) != 0) { 2775 ERROR("BMediaRoster::InstantiateDormantNode: requested " 2776 "B_FLAVOR_IS_GLOBAL, but dormant node has B_FLAVOR_IS_LOCAL\n"); 2777 return B_NAME_NOT_FOUND; 2778 } 2779 2780 // If either the node, or the caller requested to make the instance global 2781 // we will do it by forwarding this request into the media_addon_server, 2782 // which in turn will call BMediaRosterEx::InstantiateDormantNode to create 2783 // the node there and make it globally available. 2784 if ((flavorInfo.flavor_flags & B_FLAVOR_IS_GLOBAL) != 0 2785 || (flags & B_FLAVOR_IS_GLOBAL) != 0) { 2786 TRACE("BMediaRoster::InstantiateDormantNode: creating global object " 2787 "in media_addon_server\n"); 2788 2789 add_on_server_instantiate_dormant_node_request request; 2790 add_on_server_instantiate_dormant_node_reply reply; 2791 request.add_on_id = info.addon; 2792 request.flavor_id = info.flavor_id; 2793 request.creator_team = BPrivate::current_team(); 2794 // creator team is allowed to also release global nodes 2795 rv = QueryAddOnServer(ADD_ON_SERVER_INSTANTIATE_DORMANT_NODE, &request, 2796 sizeof(request), &reply, sizeof(reply)); 2797 if (rv == B_OK) 2798 *_node = reply.node; 2799 } else { 2800 // creator team = -1, as this is a local node 2801 rv = MediaRosterEx(this)->InstantiateDormantNode(info.addon, 2802 info.flavor_id, -1, _node); 2803 } 2804 if (rv != B_OK) { 2805 *_node = media_node::null; 2806 return B_NAME_NOT_FOUND; 2807 } 2808 return B_OK; 2809} 2810 2811 2812status_t 2813BMediaRoster::InstantiateDormantNode(const dormant_node_info& info, 2814 media_node* _node) 2815{ 2816 return InstantiateDormantNode(info, _node, 0); 2817} 2818 2819 2820status_t 2821BMediaRoster::GetDormantNodeFor(const media_node& node, 2822 dormant_node_info* _info) 2823{ 2824 CALLED(); 2825 if (_info == NULL) 2826 return B_BAD_VALUE; 2827 if (IS_INVALID_NODE(node)) 2828 return B_MEDIA_BAD_NODE; 2829 2830 server_get_dormant_node_for_request request; 2831 server_get_dormant_node_for_reply reply; 2832 status_t rv; 2833 2834 request.node = node; 2835 2836 rv = QueryServer(SERVER_GET_DORMANT_NODE_FOR, &request, sizeof(request), 2837 &reply, sizeof(reply)); 2838 if (rv != B_OK) 2839 return rv; 2840 2841 *_info = reply.node_info; 2842 return B_OK; 2843} 2844 2845 2846status_t 2847BMediaRosterEx::GetDormantFlavorInfo(media_addon_id addonID, int32 flavorID, 2848 dormant_flavor_info* _flavor) 2849{ 2850 CALLED(); 2851 if (_flavor == NULL) 2852 return B_BAD_VALUE; 2853 2854 // TODO: better use an area here as well! 2855 2856 server_get_dormant_flavor_info_reply* reply 2857 = (server_get_dormant_flavor_info_reply*)malloc(16300); 2858 if (reply == NULL) 2859 return B_NO_MEMORY; 2860 2861 server_get_dormant_flavor_info_request request; 2862 request.add_on_id = addonID; 2863 request.flavor_id = flavorID; 2864 2865 status_t status = QueryServer(SERVER_GET_DORMANT_FLAVOR_INFO, &request, 2866 sizeof(request), reply, 16300); 2867 if (status != B_OK) { 2868 free(reply); 2869 return status; 2870 } 2871 2872 if (reply->result == B_OK) { 2873 status = _flavor->Unflatten(reply->type, &reply->flattened_data, 2874 reply->flattened_size); 2875 } else 2876 status = reply->result; 2877 2878 free(reply); 2879 return status; 2880} 2881 2882 2883status_t 2884BMediaRoster::GetDormantFlavorInfoFor(const dormant_node_info& dormant, 2885 dormant_flavor_info* _flavor) 2886{ 2887 return MediaRosterEx(this)->GetDormantFlavorInfo(dormant.addon, 2888 dormant.flavor_id, _flavor); 2889} 2890 2891 2892// Reports in outLatency the maximum latency found downstream from 2893// the specified BBufferProducer, producer, given the current connections. 2894status_t 2895BMediaRoster::GetLatencyFor(const media_node& producer, bigtime_t* _latency) 2896{ 2897 CALLED(); 2898 if (_latency == NULL) 2899 return B_BAD_VALUE; 2900 if (IS_INVALID_NODE(producer) 2901 || (producer.kind & B_BUFFER_PRODUCER) == 0) 2902 return B_MEDIA_BAD_NODE; 2903 2904 producer_get_latency_request request; 2905 producer_get_latency_reply reply; 2906 status_t rv; 2907 2908 rv = QueryPort(producer.port, PRODUCER_GET_LATENCY, &request, 2909 sizeof(request), &reply, sizeof(reply)); 2910 if (rv != B_OK) 2911 return rv; 2912 2913 *_latency = reply.latency; 2914 2915// printf("BMediaRoster::GetLatencyFor producer %ld has maximum latency %lld\n", producer.node, *out_latency); 2916 return B_OK; 2917} 2918 2919 2920status_t 2921BMediaRoster::GetInitialLatencyFor(const media_node& producer, 2922 bigtime_t* _latency, uint32* _flags) 2923{ 2924 CALLED(); 2925 if (_latency == NULL) 2926 return B_BAD_VALUE; 2927 if (IS_INVALID_NODE(producer) 2928 || (producer.kind & B_BUFFER_PRODUCER) == 0) 2929 return B_MEDIA_BAD_NODE; 2930 2931 producer_get_initial_latency_request request; 2932 producer_get_initial_latency_reply reply; 2933 status_t rv; 2934 2935 rv = QueryPort(producer.port, PRODUCER_GET_INITIAL_LATENCY, &request, 2936 sizeof(request), &reply, sizeof(reply)); 2937 if (rv != B_OK) 2938 return rv; 2939 2940 *_latency = reply.initial_latency; 2941 if (_flags != NULL) 2942 *_flags = reply.flags; 2943 2944 TRACE("BMediaRoster::GetInitialLatencyFor producer %" B_PRId32 " has " 2945 "maximum initial latency %" B_PRId64 "\n", producer.node, *_latency); 2946 return B_OK; 2947} 2948 2949 2950status_t 2951BMediaRoster::GetStartLatencyFor(const media_node& timeSource, 2952 bigtime_t* _latency) 2953{ 2954 CALLED(); 2955 if (_latency == NULL) 2956 return B_BAD_VALUE; 2957 if (IS_INVALID_NODE(timeSource) 2958 || (timeSource.kind & B_TIME_SOURCE) == 0) 2959 return B_MEDIA_BAD_NODE; 2960 2961 timesource_get_start_latency_request request; 2962 timesource_get_start_latency_reply reply; 2963 status_t rv; 2964 2965 rv = QueryPort(timeSource.port, TIMESOURCE_GET_START_LATENCY, &request, 2966 sizeof(request), &reply, sizeof(reply)); 2967 if (rv != B_OK) 2968 return rv; 2969 2970 *_latency = reply.start_latency; 2971 2972 TRACE("BMediaRoster::GetStartLatencyFor timesource %" B_PRId32 " has " 2973 "maximum initial latency %" B_PRId64 "\n", timeSource.node, *_latency); 2974 return B_OK; 2975} 2976 2977 2978status_t 2979BMediaRoster::GetFileFormatsFor(const media_node& fileInterface, 2980 media_file_format* _formats, int32* _numFormats) 2981{ 2982 CALLED(); 2983 2984 if (IS_INVALID_NODE(fileInterface) 2985 || (fileInterface.kind & B_FILE_INTERFACE) == 0) 2986 return B_MEDIA_BAD_NODE; 2987 2988 if (_numFormats == NULL || *_numFormats < 1) 2989 return B_BAD_VALUE; 2990 2991 fileinterface_get_formats_request request; 2992 fileinterface_get_formats_reply reply; 2993 2994 media_file_format* formats; 2995 size_t needSize = sizeof(media_file_format) * *_numFormats; 2996 size_t size = (needSize + (B_PAGE_SIZE - 1)) & ~(B_PAGE_SIZE - 1); 2997 2998 area_id area = create_area("formats area", (void**)&formats, 2999 B_ANY_ADDRESS, size, B_NO_LOCK, 3000 B_READ_AREA | B_WRITE_AREA); 3001 3002 if (area < 0) 3003 return B_NO_MEMORY; 3004 3005 request.num_formats = *_numFormats; 3006 request.data_area = area; 3007 3008 status_t status = QueryPort(fileInterface.port, 3009 FILEINTERFACE_GET_FORMATS, &request, 3010 sizeof(request), &reply, sizeof(reply)); 3011 3012 if (status == B_OK) { 3013 memcpy(_formats, formats, sizeof(media_file_format)*reply.filled_slots); 3014 *_numFormats = reply.filled_slots; 3015 } 3016 delete_area(area); 3017 return status; 3018} 3019 3020 3021status_t 3022BMediaRoster::SetRefFor(const media_node& file_interface, const entry_ref& file, 3023 bool createAndTruncate, bigtime_t* _length) 3024{ 3025 CALLED(); 3026 3027 if (IS_INVALID_NODE(file_interface) 3028 || (file_interface.kind & B_FILE_INTERFACE) == 0) 3029 return B_MEDIA_BAD_NODE; 3030 3031 fileinterface_set_ref_request request; 3032 fileinterface_set_ref_reply reply; 3033 status_t rv; 3034 3035 request.device = file.device; 3036 request.directory = file.directory; 3037 strcpy(request.name, file.name); 3038 request.create = createAndTruncate; 3039 if (_length != NULL) 3040 request.duration = *_length; 3041 3042 rv = QueryPort(file_interface.port, FILEINTERFACE_SET_REF, &request, 3043 sizeof(request), &reply, sizeof(reply)); 3044 if (rv != B_OK) 3045 return rv; 3046 3047 if (!createAndTruncate && _length) 3048 *_length = reply.duration; 3049 3050 return B_OK; 3051} 3052 3053 3054status_t 3055BMediaRoster::GetRefFor(const media_node& node, entry_ref* _file, 3056 BMimeType* mimeType) 3057{ 3058 CALLED(); 3059 3060 if (IS_INVALID_NODE(node) 3061 || (node.kind & B_FILE_INTERFACE) == 0) 3062 return B_MEDIA_BAD_NODE; 3063 3064 if (!_file) 3065 return B_BAD_VALUE; 3066 3067 fileinterface_get_ref_request request; 3068 fileinterface_get_ref_reply reply; 3069 status_t rv; 3070 3071 rv = QueryPort(node.port, FILEINTERFACE_GET_REF, &request, sizeof(request), 3072 &reply, sizeof(reply)); 3073 if (rv != B_OK) 3074 return rv; 3075 3076 *_file = entry_ref(reply.device, reply.directory, reply.name); 3077 3078 if (mimeType) 3079 mimeType->SetTo(reply.mimetype); 3080 3081 return B_OK; 3082} 3083 3084 3085status_t 3086BMediaRoster::SniffRefFor(const media_node& file_interface, 3087 const entry_ref& file, BMimeType* mimeType, float* _capability) 3088{ 3089 CALLED(); 3090 3091 if (IS_INVALID_NODE(file_interface) 3092 || (file_interface.kind & B_FILE_INTERFACE) == 0) 3093 return B_MEDIA_BAD_NODE; 3094 3095 if (mimeType == NULL || _capability == NULL) 3096 return B_BAD_VALUE; 3097 3098 fileinterface_sniff_ref_request request; 3099 fileinterface_sniff_ref_reply reply; 3100 status_t rv; 3101 3102 request.device = file.device; 3103 request.directory = file.directory; 3104 strcpy(request.name, file.name); 3105 3106 rv = QueryPort(file_interface.port, FILEINTERFACE_SNIFF_REF, &request, 3107 sizeof(request), &reply, sizeof(reply)); 3108 if (rv != B_OK) 3109 return rv; 3110 3111 mimeType->SetTo(reply.mimetype); 3112 *_capability = reply.capability; 3113 3114 return B_OK; 3115} 3116 3117 3118/*! This is the generic "here's a file, now can someone please play it" 3119 interface. 3120*/ 3121status_t 3122BMediaRoster::SniffRef(const entry_ref& file, uint64 requireNodeKinds, 3123 dormant_node_info* _node, BMimeType* mimeType) 3124{ 3125 CALLED(); 3126 3127 TRACE("BMediaRoster::SniffRef looking for a node to handle %s: 0x%" B_PRIx64 3128 "\n", file.name, requireNodeKinds); 3129 3130 if (_node == NULL) 3131 return B_BAD_VALUE; 3132 3133 BMimeType aMimeType; 3134 3135 dormant_node_info nodes[30]; 3136 int32 count = 30; 3137 int32 highestCapability = -1; 3138 float capability; 3139 3140 media_node node; 3141 3142 // Get all dormant nodes using GetDormantNodes 3143 if (GetDormantNodes(nodes, &count, NULL, NULL, NULL, requireNodeKinds | B_FILE_INTERFACE, 0) == B_OK) { 3144 // Call SniffRefFor on each node that matches requireNodeKinds 3145 for (int32 i=0;i<count;i++) { 3146 if (InstantiateDormantNode(nodes[i], &node) == B_OK) { 3147 3148 if (SniffRefFor(node, file, &aMimeType, &capability) == B_OK) { 3149 // find the first node that has 100% capability 3150 TRACE("%s has a %f%% chance of playing file\n",nodes[i].name, capability * 100.0); 3151 if (capability == 1.0) { 3152 highestCapability = i; 3153 break; 3154 } 3155 } 3156 ReleaseNode(node); 3157 } 3158 } 3159 3160 if (highestCapability != -1) { 3161 *_node = nodes[highestCapability]; 3162 3163 TRACE("BMediaRoster::SniffRef: found a node %s addon-id %" B_PRId32 3164 ", flavor_id %" B_PRId32 "\n", 3165 nodes[highestCapability].name, nodes[highestCapability].addon, 3166 nodes[highestCapability].flavor_id); 3167 3168 if (mimeType != NULL) { 3169 //*mimeType = aMimeType; -- need a copy constructor 3170 } 3171 3172 return B_OK; 3173 } 3174 3175 } 3176 3177 return B_ERROR; 3178} 3179 3180 3181status_t 3182BMediaRoster::GetDormantNodeForType(const BMimeType& type, 3183 uint64 requireNodeKinds, dormant_node_info* _node) 3184{ 3185 UNIMPLEMENTED(); 3186 return B_ERROR; 3187} 3188 3189 3190status_t 3191BMediaRoster::GetReadFileFormatsFor(const dormant_node_info& node, 3192 media_file_format* _readFormats, int32 readCount, int32* _readCount) 3193{ 3194 UNIMPLEMENTED(); 3195 return B_ERROR; 3196} 3197 3198 3199status_t 3200BMediaRoster::GetWriteFileFormatsFor(const dormant_node_info& node, 3201 media_file_format* _write_formats, int32 writeCount, int32* _writeCount) 3202{ 3203 UNIMPLEMENTED(); 3204 return B_ERROR; 3205} 3206 3207 3208status_t 3209BMediaRoster::GetFormatFor(const media_output& output, media_format* _format, 3210 uint32 flags) 3211{ 3212 CALLED(); 3213 if (_format == NULL) 3214 return B_BAD_VALUE; 3215 if ((output.node.kind & B_BUFFER_PRODUCER) == 0) 3216 return B_MEDIA_BAD_NODE; 3217 if (IS_INVALID_SOURCE(output.source)) 3218 return B_MEDIA_BAD_SOURCE; 3219 3220 producer_format_suggestion_requested_request request; 3221 producer_format_suggestion_requested_reply reply; 3222 status_t rv; 3223 3224 request.type = B_MEDIA_UNKNOWN_TYPE; 3225 request.quality = 0; // TODO: what should this be? 3226 3227 rv = QueryPort(output.source.port, PRODUCER_FORMAT_SUGGESTION_REQUESTED, 3228 &request, sizeof(request), &reply, sizeof(reply)); 3229 if (rv != B_OK) 3230 return rv; 3231 3232 *_format = reply.format; 3233 return B_OK; 3234} 3235 3236 3237status_t 3238BMediaRoster::GetFormatFor(const media_input& input, media_format* _format, 3239 uint32 flags) 3240{ 3241 CALLED(); 3242 if (_format == NULL) 3243 return B_BAD_VALUE; 3244 if ((input.node.kind & B_BUFFER_CONSUMER) == 0) 3245 return B_MEDIA_BAD_NODE; 3246 if (IS_INVALID_DESTINATION(input.destination)) 3247 return B_MEDIA_BAD_DESTINATION; 3248 3249 consumer_accept_format_request request; 3250 consumer_accept_format_reply reply; 3251 status_t rv; 3252 3253 request.dest = input.destination; 3254 request.format.Clear(); // wildcard 3255 3256 rv = QueryPort(input.destination.port, CONSUMER_ACCEPT_FORMAT, &request, 3257 sizeof(request), &reply, sizeof(reply)); 3258 if (rv != B_OK) 3259 return rv; 3260 3261 *_format = reply.format; 3262 return B_OK; 3263} 3264 3265 3266status_t 3267BMediaRoster::GetFormatFor(const media_node& node, media_format* _format, 3268 float quality) 3269{ 3270 UNIMPLEMENTED(); 3271 if (_format == NULL) 3272 return B_BAD_VALUE; 3273 if (IS_INVALID_NODE(node)) 3274 return B_MEDIA_BAD_NODE; 3275 if ((node.kind & (B_BUFFER_CONSUMER | B_BUFFER_PRODUCER)) == 0) 3276 return B_MEDIA_BAD_NODE; 3277 3278 return B_ERROR; 3279} 3280 3281 3282ssize_t 3283BMediaRoster::GetNodeAttributesFor(const media_node& node, 3284 media_node_attribute* _array, size_t maxCount) 3285{ 3286 CALLED(); 3287 3288 if (IS_INVALID_NODE(node)) 3289 return B_MEDIA_BAD_NODE; 3290 3291 node_get_attributes_for_request request; 3292 node_get_attributes_for_reply reply; 3293 status_t status; 3294 3295 media_node_attribute* addr = NULL; 3296 size_t totalSize = maxCount*sizeof(media_node_attribute); 3297 size_t size = (totalSize + (B_PAGE_SIZE - 1)) & ~(B_PAGE_SIZE - 1); 3298 3299 area_id dataArea = create_area("attributes area", (void**)&addr, 3300 B_ANY_ADDRESS, size, B_NO_LOCK, 3301 B_READ_AREA | B_WRITE_AREA); 3302 // No need to memset the padding 3303 memset(addr, 0, totalSize); 3304 3305 if (dataArea < 0) 3306 return B_NO_MEMORY; 3307 3308 request.count = maxCount; 3309 request.area = dataArea; 3310 3311 status = QueryPort(node.port, NODE_GET_ATTRIBUTES_FOR, &request, 3312 sizeof(request), &reply, sizeof(reply)); 3313 if (status != B_OK) 3314 return status; 3315 3316 memcpy(_array, addr, reply.filled_count 3317 * sizeof(media_node_attribute)); 3318 3319 delete_area(dataArea); 3320 return reply.filled_count; 3321} 3322 3323 3324media_node_id 3325BMediaRoster::NodeIDFor(port_id port) 3326{ 3327 CALLED(); 3328 3329 server_node_id_for_request request; 3330 server_node_id_for_reply reply; 3331 status_t rv; 3332 3333 request.port = port; 3334 3335 rv = QueryServer(SERVER_NODE_ID_FOR, &request, sizeof(request), &reply, 3336 sizeof(reply)); 3337 if (rv != B_OK) { 3338 ERROR("BMediaRoster::NodeIDFor: failed (error %#" B_PRIx32 ")\n", rv); 3339 return -1; 3340 } 3341 3342 return reply.node_id; 3343} 3344 3345 3346status_t 3347BMediaRoster::GetInstancesFor(media_addon_id addon, int32 flavor, 3348 media_node_id* _id, int32* _count) 3349{ 3350 CALLED(); 3351 if (_id == NULL) 3352 return B_BAD_VALUE; 3353 if (_count && *_count <= 0) 3354 return B_BAD_VALUE; 3355 3356 server_get_instances_for_request request; 3357 server_get_instances_for_reply reply; 3358 status_t rv; 3359 3360 request.max_count = (_count ? *_count : 1); 3361 request.add_on_id = addon; 3362 request.flavor_id = flavor; 3363 3364 rv = QueryServer(SERVER_GET_INSTANCES_FOR, &request, sizeof(request), 3365 &reply, sizeof(reply)); 3366 if (rv != B_OK) { 3367 ERROR("BMediaRoster::GetLiveNodes failed\n"); 3368 return rv; 3369 } 3370 3371 if (_count) 3372 *_count = reply.count; 3373 if (reply.count > 0) 3374 memcpy(_id, reply.node_id, sizeof(media_node_id) * reply.count); 3375 3376 return B_OK; 3377} 3378 3379 3380bool 3381BMediaRoster::IsRunning() 3382{ 3383 return be_roster->IsRunning(B_MEDIA_SERVER_SIGNATURE) 3384 && be_roster->IsRunning(B_MEDIA_ADDON_SERVER_SIGNATURE); 3385} 3386 3387 3388ssize_t 3389BMediaRoster::AudioBufferSizeFor(int32 channelCount, uint32 sampleFormat, 3390 float frameRate, bus_type busKind) 3391{ 3392 bigtime_t bufferDuration; 3393 ssize_t bufferSize; 3394 3395 if (busKind == B_ISA_BUS || busKind == B_PCMCIA_BUS) 3396 bufferDuration = 25000; 3397 else 3398 bufferDuration = 10000; 3399 3400 bufferSize = (sampleFormat & 0xf) * channelCount 3401 * (ssize_t)((frameRate * bufferDuration) / 1000000.0); 3402 3403 printf("Suggested buffer duration %" B_PRId64 ", size %" B_PRIdSSIZE "\n", 3404 bufferDuration, bufferSize); 3405 3406 return bufferSize; 3407} 3408 3409 3410/*! Use MediaFlags to inquire about specific features of the Media Kit. 3411 Returns < 0 for "not present", positive size for output data size. 3412 0 means that the capability is present, but no data about it. 3413*/ 3414/*static*/ ssize_t 3415BMediaRoster::MediaFlags(media_flags cap, void* buffer, size_t maxSize) 3416{ 3417 UNIMPLEMENTED(); 3418 return 0; 3419} 3420 3421 3422// #pragma mark - BLooper overrides 3423 3424 3425void 3426BMediaRoster::MessageReceived(BMessage* message) 3427{ 3428 switch (message->what) { 3429 case MEDIA_ROSTER_REQUEST_NOTIFICATIONS: 3430 { 3431 RosterNotification notification; 3432 if (message->FindInt32(NOTIFICATION_PARAM_WHAT, ¬ification.what) 3433 != B_OK) { 3434 TRACE("BMediaRoster MEDIA_ROSTER_REQUEST_NOTIFICATIONS can't" 3435 "find what parameter"); 3436 return; 3437 } 3438 if (message->FindMessenger(NOTIFICATION_PARAM_MESSENGER, 3439 ¬ification.messenger) != B_OK) { 3440 TRACE("BMediaRoster MEDIA_ROSTER_REQUEST_NOTIFICATIONS can't" 3441 "find messenger"); 3442 return; 3443 } 3444 sNotificationList.Insert(notification); 3445 return; 3446 } 3447 3448 case MEDIA_ROSTER_CANCEL_NOTIFICATIONS: 3449 { 3450 RosterNotification notification; 3451 if (message->FindInt32(NOTIFICATION_PARAM_WHAT, ¬ification.what) 3452 != B_OK) { 3453 TRACE("BMediaRoster MEDIA_ROSTER_CANCEL_NOTIFICATIONS can't" 3454 "find what parameter"); 3455 return; 3456 } 3457 if (message->FindMessenger(NOTIFICATION_PARAM_MESSENGER, 3458 ¬ification.messenger) != B_OK) { 3459 TRACE("BMediaRoster MEDIA_ROSTER_CANCEL_NOTIFICATIONS can't" 3460 "find messenger"); 3461 return; 3462 } 3463 for (int32 i = 0; i < sNotificationList.CountItems(); i++) { 3464 RosterNotification* current; 3465 if (sNotificationList.Get(i, ¤t) != true) 3466 return; 3467 if (current->what == notification.what 3468 && current->messenger == notification.messenger) { 3469 sNotificationList.Remove(i); 3470 return; 3471 } 3472 } 3473 return; 3474 } 3475 3476 case B_SOME_APP_LAUNCHED: 3477 { 3478 BString mimeSig; 3479 if (message->FindString("be:signature", &mimeSig) != B_OK) 3480 return; 3481 if (mimeSig != B_MEDIA_ADDON_SERVER_SIGNATURE 3482 && mimeSig != B_MEDIA_SERVER_SIGNATURE) 3483 return; 3484 3485 TRACE("BMediaRoster::MessageReceived media services are going up."); 3486 3487 if (BMediaRoster::IsRunning()) { 3488 // Wait for media services to wake up and restore our friendship 3489 if (MediaRosterEx(this)->BuildConnections() != B_OK) { 3490 TRACE("BMediaRoster::MessageReceived can't reconnect" 3491 "to media_server."); 3492 } 3493 } 3494 return; 3495 } 3496 3497 case B_SOME_APP_QUIT: 3498 { 3499 BString mimeSig; 3500 if (message->FindString("be:signature", &mimeSig) != B_OK) 3501 return; 3502 if (mimeSig != B_MEDIA_ADDON_SERVER_SIGNATURE 3503 && mimeSig != B_MEDIA_SERVER_SIGNATURE) 3504 return; 3505 3506 TRACE("BMediaRoster::MessageReceived media services are down."); 3507 3508 // Send the notification to our subscribers 3509 if (!BMediaRoster::IsRunning() && sServerIsUp == true) { 3510 sServerIsUp = false; 3511 for (int32 i = 0; i < sNotificationList.CountItems(); i++) { 3512 RosterNotification* current; 3513 if (sNotificationList.Get(i, ¤t) != true) 3514 return; 3515 if (current->what == B_MEDIA_SERVER_QUIT) { 3516 if (current->messenger.SendMessage( 3517 B_MEDIA_SERVER_QUIT) != B_OK) { 3518 if(!current->messenger.IsValid()) 3519 sNotificationList.Remove(i); 3520 } 3521 } 3522 } 3523 } 3524 return; 3525 } 3526 3527 case MEDIA_SERVER_ALIVE: 3528 { 3529 if (!BMediaRoster::IsRunning()) 3530 return; 3531 3532 sServerIsUp = true; 3533 3534 TRACE("BMediaRoster::MessageReceived media services are" 3535 " finally up."); 3536 3537 if (MediaRosterEx(this)->fLaunchNotification) { 3538 progress_startup(100, NULL, NULL); 3539 if (MediaRosterEx(this)->fAutoExit) 3540 MediaRosterEx(this)->fLaunchNotification = false; 3541 } 3542 3543 // Send the notification to our subscribers 3544 for (int32 i = 0; i < sNotificationList.CountItems(); i++) { 3545 RosterNotification* current; 3546 if (sNotificationList.Get(i, ¤t) != true) 3547 return; 3548 if (current->what == B_MEDIA_SERVER_STARTED) { 3549 if (current->messenger.SendMessage( 3550 B_MEDIA_SERVER_STARTED) != B_OK) { 3551 if(!current->messenger.IsValid()) 3552 sNotificationList.Remove(i); 3553 } 3554 } 3555 } 3556 return; 3557 } 3558 3559 case NODE_FINAL_RELEASE: 3560 { 3561 // This function is called by a BMediaNode to delete 3562 // itself, as this needs to be done from another thread 3563 // context, it is done here. 3564 3565 BMediaNode* node = NULL; 3566 status_t err = message->FindPointer("node", 3567 reinterpret_cast<void **>(&node)); 3568 if (err == B_OK && node != NULL) 3569 node->Release(); 3570 else { 3571 TRACE("BMediaRoster::MessageReceived: CRITICAL! received" 3572 "a release request but the node can't be found."); 3573 } 3574 return; 3575 } 3576 3577 default: 3578 BLooper::MessageReceived(message); 3579 break; 3580 } 3581} 3582 3583 3584bool 3585BMediaRoster::QuitRequested() 3586{ 3587 CALLED(); 3588 return true; 3589} 3590 3591 3592BHandler* 3593BMediaRoster::ResolveSpecifier(BMessage* msg, int32 index, BMessage* specifier, 3594 int32 form, const char* property) 3595{ 3596 return BLooper::ResolveSpecifier(msg, index, specifier, form, property); 3597} 3598 3599 3600status_t 3601BMediaRoster::GetSupportedSuites(BMessage* data) 3602{ 3603 return BLooper::GetSupportedSuites(data); 3604} 3605 3606 3607BMediaRoster::~BMediaRoster() 3608{ 3609 CALLED(); 3610 3611 // Unset the global instance pointer, the destructor is also called 3612 // if a client app calls Lock(); and Quit(); directly. 3613 sDefaultInstance = NULL; 3614} 3615 3616// #pragma mark - private BMediaRoster 3617 3618// FBC reserved virtuals 3619status_t BMediaRoster::_Reserved_MediaRoster_0(void*) { return B_ERROR; } 3620status_t BMediaRoster::_Reserved_MediaRoster_1(void*) { return B_ERROR; } 3621status_t BMediaRoster::_Reserved_MediaRoster_2(void*) { return B_ERROR; } 3622status_t BMediaRoster::_Reserved_MediaRoster_3(void*) { return B_ERROR; } 3623status_t BMediaRoster::_Reserved_MediaRoster_4(void*) { return B_ERROR; } 3624status_t BMediaRoster::_Reserved_MediaRoster_5(void*) { return B_ERROR; } 3625status_t BMediaRoster::_Reserved_MediaRoster_6(void*) { return B_ERROR; } 3626status_t BMediaRoster::_Reserved_MediaRoster_7(void*) { return B_ERROR; } 3627 3628 3629BMediaRoster::BMediaRoster() 3630 : 3631 BLooper("_BMediaRoster_", B_URGENT_DISPLAY_PRIORITY, 3632 B_LOOPER_PORT_DEFAULT_CAPACITY) 3633{ 3634 CALLED(); 3635 3636 // start the looper 3637 Run(); 3638} 3639 3640// #pragma mark - static variables 3641 3642BMediaRoster* BMediaRoster::sDefaultInstance = NULL; 3643