src/kits/media/BufferProducer.cpp

   1 /*
   2  * Copyright 2010-2012, Axel Dörfler, axeld@pinc-software.de.
   3  * Copyright 2002-2003, Marcus Overhagen, <Marcus@Overhagen.de>.
   4  * Distributed under the terms of the MIT License.
   5  */
   6
   7
   8 #include <Buffer.h>
   9 #include <BufferConsumer.h>
  10 #include <BufferGroup.h>
  11 #include <BufferProducer.h>
  12
  13 #include "debug.h"
  14 #include "DataExchange.h"
  15 #include "MediaMisc.h"
  16
  17
  18 // #pragma mark - protected BBufferProducer
  19
  20
  21 BBufferProducer::~BBufferProducer()
  22 {
  23         CALLED();
  24 }
  25
  26
  27 // #pragma mark - public BBufferProducer
  28
  29
  30 /*static*/ status_t
  31 BBufferProducer::ClipDataToRegion(int32 format, int32 size, const void* data,
  32         BRegion* region)
  33 {
  34         CALLED();
  35
  36         if (format != B_CLIP_SHORT_RUNS)
  37                 return B_MEDIA_BAD_CLIP_FORMAT;
  38
  39         return clip_shorts_to_region((const int16*)data, size / sizeof(int16),
  40                 region);
  41 }
  42
  43
  44 media_type
  45 BBufferProducer::ProducerType()
  46 {
  47         CALLED();
  48         return fProducerType;
  49 }
  50
  51
  52 // #pragma mark - protected BBufferProducer
  53
  54
  55 BBufferProducer::BBufferProducer(media_type producer_type)
  56         :
  57         BMediaNode("called by BBufferProducer"),
  58         fProducerType(producer_type),
  59         fInitialLatency(0),
  60         fInitialFlags(0),
  61         fDelay(0)
  62 {
  63         CALLED();
  64
  65         AddNodeKind(B_BUFFER_PRODUCER);
  66 }
  67
  68
  69 status_t
  70 BBufferProducer::VideoClippingChanged(const media_source& source,
  71         int16 numShorts, int16* clipData, const media_video_display_info& display,
  72         int32* /*_deprecated_*/)
  73 {
  74         CALLED();
  75         // may be implemented by derived classes
  76         return B_ERROR;
  77 }
  78
  79
  80 status_t
  81 BBufferProducer::GetLatency(bigtime_t* _latency)
  82 {
  83         CALLED();
  84         // The default implementation of GetLatency() finds the maximum
  85         // latency of your currently-available outputs by iterating over
  86         // them, and returns that value in outLatency
  87
  88         int32 cookie;
  89         bigtime_t latency;
  90         media_output output;
  91         media_node_id unused;
  92
  93         *_latency = 0;
  94         cookie = 0;
  95         while (GetNextOutput(&cookie, &output) == B_OK) {
  96                 if (output.destination == media_destination::null)
  97                         continue;
  98
  99                 if (output.node.node == fNodeID) {
 100                         // avoid port writes (deadlock) if loopback connection
 101                         if (fConsumerThis == NULL)
 102                                 fConsumerThis = dynamic_cast<BBufferConsumer*>(this);
 103                         if (fConsumerThis == NULL)
 104                                 continue;
 105
 106                         latency = 0;
 107                         if (fConsumerThis->GetLatencyFor(output.destination, &latency,
 108                                         &unused) == B_OK && latency > *_latency) {
 109                                 *_latency = latency;
 110                         }
 111                 } else if (FindLatencyFor(output.destination, &latency, &unused)
 112                                 == B_OK &&  latency > *_latency) {
 113                         *_latency = latency;
 114                 }
 115         }
 116         printf("BBufferProducer::GetLatency: node %" B_PRId32 ", name \"%s\" has "
 117                 "max latency %" B_PRId64 "\n", fNodeID, fName, *_latency);
 118         return B_OK;
 119 }
 120
 121
 122 status_t
 123 BBufferProducer::SetPlayRate(int32 numer, int32 denom)
 124 {
 125         CALLED();
 126         // may be implemented by derived classes
 127         return B_ERROR;
 128 }
 129
 130
 131 status_t
 132 BBufferProducer::HandleMessage(int32 message, const void* data, size_t size)
 133 {
 134         PRINT(4, "BBufferProducer::HandleMessage %#lx, node %ld\n", message,
 135                 fNodeID);
 136
 137         switch (message) {
 138                 case PRODUCER_SET_RUN_MODE_DELAY:
 139                 {
 140                         const producer_set_run_mode_delay_command* command
 141                                 = static_cast<const producer_set_run_mode_delay_command*>(data);
 142                         // when changing this, also change NODE_SET_RUN_MODE
 143                         fDelay = command->delay;
 144                         fRunMode = command->mode;
 145
 146                         TRACE("PRODUCER_SET_RUN_MODE_DELAY: fDelay now %" B_PRId64 "\n",
 147                                 fDelay);
 148
 149                         SetRunMode(fRunMode);
 150                         return B_OK;
 151                 }
 152
 153                 case PRODUCER_FORMAT_SUGGESTION_REQUESTED:
 154                 {
 155                         const producer_format_suggestion_requested_request* request
 156                                 = static_cast<
 157                                         const producer_format_suggestion_requested_request*>(data);
 158                         producer_format_suggestion_requested_reply reply;
 159                         status_t status = FormatSuggestionRequested(request->type,
 160                                 request->quality, &reply.format);
 161                         request->SendReply(status, &reply, sizeof(reply));
 162                         return B_OK;
 163                 }
 164
 165                 case PRODUCER_FORMAT_PROPOSAL:
 166                 {
 167                         const producer_format_proposal_request* request
 168                                 = static_cast<const producer_format_proposal_request*>(data);
 169                         producer_format_proposal_reply reply;
 170                         reply.format = request->format;
 171                         status_t status = FormatProposal(request->output, &reply.format);
 172                         request->SendReply(status, &reply, sizeof(reply));
 173                         return B_OK;
 174                 }
 175
 176                 case PRODUCER_PREPARE_TO_CONNECT:
 177                 {
 178                         const producer_prepare_to_connect_request* request
 179                                 = static_cast<const producer_prepare_to_connect_request*>(data);
 180                         producer_prepare_to_connect_reply reply;
 181                         reply.format = request->format;
 182                         reply.out_source = request->source;
 183                         memcpy(reply.name, request->name, B_MEDIA_NAME_LENGTH);
 184                         status_t status = PrepareToConnect(request->source,
 185                                 request->destination, &reply.format, &reply.out_source,
 186                                 reply.name);
 187                         request->SendReply(status, &reply, sizeof(reply));
 188                         return B_OK;
 189                 }
 190
 191                 case PRODUCER_CONNECT:
 192                 {
 193                         const producer_connect_request* request
 194                                 = static_cast<const producer_connect_request*>(data);
 195                         producer_connect_reply reply;
 196                         memcpy(reply.name, request->name, B_MEDIA_NAME_LENGTH);
 197                         Connect(request->error, request->source, request->destination,
 198                                 request->format, reply.name);
 199                         request->SendReply(B_OK, &reply, sizeof(reply));
 200                         return B_OK;
 201                 }
 202
 203                 case PRODUCER_DISCONNECT:
 204                 {
 205                         const producer_disconnect_request* request
 206                                 = static_cast<const producer_disconnect_request*>(data);
 207                         producer_disconnect_reply reply;
 208                         Disconnect(request->source, request->destination);
 209                         request->SendReply(B_OK, &reply, sizeof(reply));
 210                         return B_OK;
 211                 }
 212
 213                 case PRODUCER_GET_INITIAL_LATENCY:
 214                 {
 215                         const producer_get_initial_latency_request* request
 216                                 = static_cast<
 217                                         const producer_get_initial_latency_request*>(data);
 218                         producer_get_initial_latency_reply reply;
 219                         reply.initial_latency = fInitialLatency;
 220                         reply.flags = fInitialFlags;
 221                         request->SendReply(B_OK, &reply, sizeof(reply));
 222                         return B_OK;
 223                 }
 224
 225                 case PRODUCER_SET_PLAY_RATE:
 226                 {
 227                         const producer_set_play_rate_request* request
 228                                 = static_cast<const producer_set_play_rate_request*>(data);
 229                         producer_set_play_rate_reply reply;
 230                         status_t status = SetPlayRate(request->numer, request->denom);
 231                         request->SendReply(status, &reply, sizeof(reply));
 232                         return B_OK;
 233                 }
 234
 235                 case PRODUCER_GET_LATENCY:
 236                 {
 237                         const producer_get_latency_request* request
 238                                 = static_cast<const producer_get_latency_request*>(data);
 239                         producer_get_latency_reply reply;
 240                         status_t status = GetLatency(&reply.latency);
 241                         request->SendReply(status, &reply, sizeof(reply));
 242                         return B_OK;
 243                 }
 244
 245                 case PRODUCER_GET_NEXT_OUTPUT:
 246                 {
 247                         const producer_get_next_output_request* request
 248                                 = static_cast<const producer_get_next_output_request*>(data);
 249                         producer_get_next_output_reply reply;
 250                         reply.cookie = request->cookie;
 251                         status_t status = GetNextOutput(&reply.cookie, &reply.output);
 252                         request->SendReply(status, &reply, sizeof(reply));
 253                         return B_OK;
 254                 }
 255
 256                 case PRODUCER_DISPOSE_OUTPUT_COOKIE:
 257                 {
 258                         const producer_dispose_output_cookie_request*request
 259                                 = static_cast<
 260                                         const producer_dispose_output_cookie_request*>(data);
 261                         producer_dispose_output_cookie_reply reply;
 262                         DisposeOutputCookie(request->cookie);
 263                         request->SendReply(B_OK, &reply, sizeof(reply));
 264                         return B_OK;
 265                 }
 266
 267                 case PRODUCER_SET_BUFFER_GROUP:
 268                 {
 269                         const producer_set_buffer_group_command* command
 270                                 = static_cast<const producer_set_buffer_group_command*>(data);
 271                         node_request_completed_command replycommand;
 272                         BBufferGroup *group;
 273                         group = command->buffer_count != 0
 274                                 ? new BBufferGroup(command->buffer_count, command->buffers)
 275                                 : NULL;
 276
 277                         if (group != NULL && group->InitCheck() != B_OK) {
 278                                 ERROR("BBufferProducer::HandleMessage PRODUCER_SET_BUFFER_GROUP"
 279                                         " group InitCheck() failed.\n");
 280                                 delete group;
 281                                 group = NULL;
 282                         }
 283                         status_t status = SetBufferGroup(command->source, group);
 284                         if (command->destination == media_destination::null)
 285                                 return B_OK;
 286                         replycommand.info.what
 287                                 = media_request_info::B_SET_OUTPUT_BUFFERS_FOR;
 288                         replycommand.info.change_tag = command->change_tag;
 289                         replycommand.info.status = status;
 290                         replycommand.info.cookie = group;
 291                         replycommand.info.user_data = command->user_data;
 292                         replycommand.info.source = command->source;
 293                         replycommand.info.destination = command->destination;
 294                         SendToPort(command->destination.port, NODE_REQUEST_COMPLETED,
 295                                 &replycommand, sizeof(replycommand));
 296                         return B_OK;
 297                 }
 298
 299                 case PRODUCER_FORMAT_CHANGE_REQUESTED:
 300                 {
 301                         const producer_format_change_requested_command* command
 302                                 = static_cast<
 303                                         const producer_format_change_requested_command*>(data);
 304                         node_request_completed_command replycommand;
 305                         replycommand.info.format = command->format;
 306                         status_t status = FormatChangeRequested(command->source,
 307                                 command->destination, &replycommand.info.format, NULL);
 308                         if (command->destination == media_destination::null)
 309                                 return B_OK;
 310                         replycommand.info.what
 311                                 = media_request_info::B_REQUEST_FORMAT_CHANGE;
 312                         replycommand.info.change_tag = command->change_tag;
 313                         replycommand.info.status = status;
 314                         //replycommand.info.cookie
 315                         replycommand.info.user_data = command->user_data;
 316                         replycommand.info.source = command->source;
 317                         replycommand.info.destination = command->destination;
 318                         SendToPort(command->destination.port, NODE_REQUEST_COMPLETED,
 319                                 &replycommand, sizeof(replycommand));
 320                         return B_OK;
 321                 }
 322
 323                 case PRODUCER_VIDEO_CLIPPING_CHANGED:
 324                 {
 325                         const producer_video_clipping_changed_command* command
 326                                 = static_cast<
 327                                         const producer_video_clipping_changed_command*>(data);
 328                         node_request_completed_command replycommand;
 329                         status_t status = VideoClippingChanged(command->source,
 330                                 command->short_count, (int16 *)command->shorts,
 331                                 command->display, NULL);
 332                         if (command->destination == media_destination::null)
 333                                 return B_OK;
 334                         replycommand.info.what
 335                                 = media_request_info::B_SET_VIDEO_CLIPPING_FOR;
 336                         replycommand.info.change_tag = command->change_tag;
 337                         replycommand.info.status = status;
 338                         //replycommand.info.cookie
 339                         replycommand.info.user_data = command->user_data;
 340                         replycommand.info.source = command->source;
 341                         replycommand.info.destination = command->destination;
 342                         replycommand.info.format.type = B_MEDIA_RAW_VIDEO;
 343                         replycommand.info.format.u.raw_video.display = command->display;
 344                         SendToPort(command->destination.port, NODE_REQUEST_COMPLETED,
 345                                 &replycommand, sizeof(replycommand));
 346                         return B_OK;
 347                 }
 348
 349                 case PRODUCER_ADDITIONAL_BUFFER_REQUESTED:
 350                 {
 351                         const producer_additional_buffer_requested_command* command
 352                                 = static_cast<
 353                                         const producer_additional_buffer_requested_command*>(data);
 354                         AdditionalBufferRequested(command->source, command->prev_buffer,
 355                                 command->prev_time, command->has_seek_tag
 356                                         ? &command->prev_tag : NULL);
 357                         return B_OK;
 358                 }
 359
 360                 case PRODUCER_LATENCY_CHANGED:
 361                 {
 362                         const producer_latency_changed_command* command
 363                                 = static_cast<const producer_latency_changed_command*>(data);
 364                         LatencyChanged(command->source, command->destination,
 365                                 command->latency, command->flags);
 366                         return B_OK;
 367                 }
 368
 369                 case PRODUCER_LATE_NOTICE_RECEIVED:
 370                 {
 371                         const producer_late_notice_received_command* command
 372                                 = static_cast<
 373                                         const producer_late_notice_received_command*>(data);
 374                         LateNoticeReceived(command->source, command->how_much,
 375                                 command->performance_time);
 376                         return B_OK;
 377                 }
 378
 379                 case PRODUCER_ENABLE_OUTPUT:
 380                 {
 381                         const producer_enable_output_command* command
 382                                 = static_cast<const producer_enable_output_command*>(data);
 383                         node_request_completed_command replycommand;
 384                         EnableOutput(command->source, command->enabled, NULL);
 385                         if (command->destination == media_destination::null)
 386                                 return B_OK;
 387
 388                         replycommand.info.what = media_request_info::B_SET_OUTPUT_ENABLED;
 389                         replycommand.info.change_tag = command->change_tag;
 390                         replycommand.info.status = B_OK;
 391                         //replycommand.info.cookie
 392                         replycommand.info.user_data = command->user_data;
 393                         replycommand.info.source = command->source;
 394                         replycommand.info.destination = command->destination;
 395                         //replycommand.info.format
 396                         SendToPort(command->destination.port, NODE_REQUEST_COMPLETED,
 397                                 &replycommand, sizeof(replycommand));
 398                         return B_OK;
 399                 }
 400         }
 401
 402         return B_ERROR;
 403 }
 404
 405
 406 void
 407 BBufferProducer::AdditionalBufferRequested(const media_source& source,
 408         media_buffer_id previousBuffer, bigtime_t previousTime,
 409         const media_seek_tag* previousTag)
 410 {
 411         CALLED();
 412         // may be implemented by derived classes
 413 }
 414
 415
 416 void
 417 BBufferProducer::LatencyChanged(const media_source& source,
 418         const media_destination& destination, bigtime_t newLatency, uint32 flags)
 419 {
 420         CALLED();
 421         // may be implemented by derived classes
 422 }
 423
 424
 425 status_t
 426 BBufferProducer::SendBuffer(BBuffer* buffer, const media_source& source,
 427         const media_destination& destination)
 428 {
 429         CALLED();
 430         if (destination == media_destination::null)
 431                 return B_MEDIA_BAD_DESTINATION;
 432         if (source == media_source::null)
 433                 return B_MEDIA_BAD_SOURCE;
 434         if (buffer == NULL)
 435                 return B_BAD_VALUE;
 436
 437         consumer_buffer_received_command command;
 438         command.buffer = buffer->ID();
 439         command.header = *buffer->Header();
 440         command.header.buffer = command.buffer;
 441         command.header.source_port = source.port;
 442         command.header.source = source.id;
 443         command.header.destination = destination.id;
 444         command.header.owner = 0; // XXX fill with "buffer owner info area"
 445         command.header.start_time += fDelay;
 446                 // time compensation as set by BMediaRoster::SetProducerRunModeDelay()
 447
 448         //printf("BBufferProducer::SendBuffer     node %2ld, buffer %2ld, start_time %12Ld with lateness %6Ld\n", ID(), buffer->Header()->buffer, command.header.start_time, TimeSource()->Now() - command.header.start_time);
 449
 450         return SendToPort(destination.port, CONSUMER_BUFFER_RECEIVED, &command,
 451                 sizeof(command));
 452 }
 453
 454
 455 status_t
 456 BBufferProducer::SendDataStatus(int32 status,
 457         const media_destination& destination, bigtime_t atTime)
 458 {
 459         CALLED();
 460         if (IS_INVALID_DESTINATION(destination))
 461                 return B_MEDIA_BAD_DESTINATION;
 462
 463         consumer_producer_data_status_command command;
 464         command.for_whom = destination;
 465         command.status = status;
 466         command.at_performance_time = atTime;
 467
 468         return SendToPort(destination.port, CONSUMER_PRODUCER_DATA_STATUS, &command,
 469                 sizeof(command));
 470 }
 471
 472
 473 status_t
 474 BBufferProducer::ProposeFormatChange(media_format* format,
 475         const media_destination& destination)
 476 {
 477         CALLED();
 478         if (IS_INVALID_DESTINATION(destination))
 479                 return B_MEDIA_BAD_DESTINATION;
 480
 481         consumer_accept_format_request request;
 482         consumer_accept_format_reply reply;
 483
 484         request.dest = destination;
 485         request.format = *format;
 486         status_t status = QueryPort(destination.port, CONSUMER_ACCEPT_FORMAT,
 487                 &request, sizeof(request), &reply, sizeof(reply));
 488         if (status != B_OK)
 489                 return status;
 490
 491         *format = reply.format;
 492         return B_OK;
 493 }
 494
 495
 496 status_t
 497 BBufferProducer::ChangeFormat(const media_source& source,
 498         const media_destination& destination, media_format* format)
 499 {
 500         CALLED();
 501         if (IS_INVALID_SOURCE(source))
 502                 return B_MEDIA_BAD_SOURCE;
 503         if (IS_INVALID_DESTINATION(destination))
 504                 return B_MEDIA_BAD_DESTINATION;
 505
 506         consumer_format_changed_request request;
 507         consumer_format_changed_reply reply;
 508
 509         request.producer = source;
 510         request.consumer = destination;
 511         request.format = *format;
 512
 513         // we use a request/reply to make this synchronous
 514         return QueryPort(destination.port, CONSUMER_FORMAT_CHANGED, &request,
 515                 sizeof(request), &reply, sizeof(reply));
 516 }
 517
 518
 519 status_t
 520 BBufferProducer::FindLatencyFor(const media_destination& destination,
 521         bigtime_t* _latency, media_node_id* _timesource)
 522 {
 523         CALLED();
 524         if (IS_INVALID_DESTINATION(destination))
 525                 return B_MEDIA_BAD_DESTINATION;
 526
 527         consumer_get_latency_for_request request;
 528         consumer_get_latency_for_reply reply;
 529
 530         request.for_whom = destination;
 531
 532         status_t status = QueryPort(destination.port, CONSUMER_GET_LATENCY_FOR,
 533                 &request, sizeof(request), &reply, sizeof(reply));
 534         if (status != B_OK)
 535                 return status;
 536
 537         *_latency = reply.latency;
 538         *_timesource = reply.timesource;
 539         return B_OK;
 540 }
 541
 542
 543 status_t
 544 BBufferProducer::FindSeekTag(const media_destination& destination,
 545         bigtime_t targetTime, media_seek_tag* _tag, bigtime_t* _tagged_time,
 546         uint32* _flags, uint32 flags)
 547 {
 548         CALLED();
 549         if (IS_INVALID_DESTINATION(destination))
 550                 return B_MEDIA_BAD_DESTINATION;
 551
 552         consumer_seek_tag_requested_request request;
 553         consumer_seek_tag_requested_reply reply;
 554
 555         request.destination = destination;
 556         request.target_time = targetTime;
 557         request.flags = flags;
 558
 559         status_t status = QueryPort(destination.port, CONSUMER_SEEK_TAG_REQUESTED,
 560                 &request, sizeof(request), &reply, sizeof(reply));
 561         if (status != B_OK)
 562                 return status;
 563
 564         *_tag = reply.seek_tag;
 565         *_tagged_time = reply.tagged_time;
 566         *_flags = reply.flags;
 567         return B_OK;
 568 }
 569
 570
 571 void
 572 BBufferProducer::SetInitialLatency(bigtime_t initialLatency, uint32 flags)
 573 {
 574         fInitialLatency = initialLatency;
 575         fInitialFlags = flags;
 576 }
 577
 578
 579 // #pragma mark - private BBufferProducer
 580
 581
 582 /*
 583 private unimplemented
 584 BBufferProducer::BBufferProducer()
 585 BBufferProducer::BBufferProducer(const BBufferProducer &clone)
 586 BBufferProducer & BBufferProducer::operator=(const BBufferProducer &clone)
 587 */
 588
 589 status_t BBufferProducer::_Reserved_BufferProducer_0(void*) { return B_ERROR; }
 590 status_t BBufferProducer::_Reserved_BufferProducer_1(void*) { return B_ERROR; }
 591 status_t BBufferProducer::_Reserved_BufferProducer_2(void*) { return B_ERROR; }
 592 status_t BBufferProducer::_Reserved_BufferProducer_3(void*) { return B_ERROR; }
 593 status_t BBufferProducer::_Reserved_BufferProducer_4(void*) { return B_ERROR; }
 594 status_t BBufferProducer::_Reserved_BufferProducer_5(void*) { return B_ERROR; }
 595 status_t BBufferProducer::_Reserved_BufferProducer_6(void*) { return B_ERROR; }
 596 status_t BBufferProducer::_Reserved_BufferProducer_7(void*) { return B_ERROR; }
 597 status_t BBufferProducer::_Reserved_BufferProducer_8(void*) { return B_ERROR; }
 598 status_t BBufferProducer::_Reserved_BufferProducer_9(void*) { return B_ERROR; }
 599 status_t BBufferProducer::_Reserved_BufferProducer_10(void*) { return B_ERROR; }
 600 status_t BBufferProducer::_Reserved_BufferProducer_11(void*) { return B_ERROR; }
 601 status_t BBufferProducer::_Reserved_BufferProducer_12(void*) { return B_ERROR; }
 602 status_t BBufferProducer::_Reserved_BufferProducer_13(void*) { return B_ERROR; }
 603 status_t BBufferProducer::_Reserved_BufferProducer_14(void*) { return B_ERROR; }
 604 status_t BBufferProducer::_Reserved_BufferProducer_15(void*) { return B_ERROR; }
 605
 606
 607 //! Deprecated.
 608 status_t
 609 BBufferProducer::SendBuffer(BBuffer* buffer,
 610         const media_destination& destination)
 611 {
 612         CALLED();
 613
 614         // Try to find the source - this is the best we can do
 615         media_output output;
 616         int32 cookie = 0;
 617         status_t status = GetNextOutput(&cookie, &output);
 618         if (status != B_OK)
 619                 return status;
 620
 621         return SendBuffer(buffer, output.source, destination);
 622 }
 623
 624
 625 status_t
 626 BBufferProducer::clip_shorts_to_region(const int16* data, int count,
 627         BRegion* output)
 628 {
 629         UNIMPLEMENTED();
 630         return B_ERROR;
 631 }
 632
 633
 634 status_t
 635 BBufferProducer::clip_region_to_shorts(const BRegion* input, int16* data,
 636         int maxCount, int* _count)
 637 {
 638         UNIMPLEMENTED();
 639         return B_ERROR;
 640 }