src/kits/media/experimental/MediaClientNode.cpp

   1 /*
   2  * Copyright 2015, Dario Casalinuovo. All rights reserved.
   3  * Distributed under the terms of the MIT License.
   4  */
   5
   6 #include "MediaClientNode.h"
   7
   8 #include <MediaClient.h>
   9 #include <MediaConnection.h>
  10 #include <scheduler.h>
  11 #include <TimeSource.h>
  12
  13 #include <string.h>
  14
  15 #include "debug.h"
  16
  17 #define B_NEW_BUFFER (BTimedEventQueue::B_USER_EVENT + 1)
  18
  19
  20 BMediaClientNode::BMediaClientNode(const char* name,
  21         BMediaClient* owner, media_type type)
  22         :
  23         BMediaNode(name),
  24         BBufferConsumer(type),
  25         BBufferProducer(type),
  26         BMediaEventLooper(),
  27         fOwner(owner)
  28 {
  29         CALLED();
  30
  31         // Configure the node to do the requested jobs
  32         if (fOwner->Kinds() & B_MEDIA_PLAYER)
  33                 AddNodeKind(B_BUFFER_PRODUCER);
  34         if (fOwner->Kinds() & B_MEDIA_RECORDER)
  35                 AddNodeKind(B_BUFFER_CONSUMER);
  36         if (fOwner->Kinds() & B_MEDIA_CONTROLLABLE)
  37                 AddNodeKind(B_CONTROLLABLE);
  38 }
  39
  40
  41 status_t
  42 BMediaClientNode::SendBuffer(BBuffer* buffer, BMediaConnection* conn)
  43 {
  44         return BBufferProducer::SendBuffer(buffer, conn->_Source(), conn->_Destination());
  45 }
  46
  47
  48 BMediaAddOn*
  49 BMediaClientNode::AddOn(int32* id) const
  50 {
  51         CALLED();
  52
  53         return fOwner->AddOn(id);
  54 }
  55
  56
  57 void
  58 BMediaClientNode::NodeRegistered()
  59 {
  60         CALLED();
  61
  62         Run();
  63 }
  64
  65
  66 void
  67 BMediaClientNode::SetRunMode(run_mode mode)
  68 {
  69         CALLED();
  70
  71         int32 priority;
  72         if (mode == BMediaNode::B_OFFLINE)
  73                 priority = B_OFFLINE_PROCESSING;
  74         else {
  75                 switch(ConsumerType()) {
  76                         case B_MEDIA_RAW_AUDIO:
  77                         case B_MEDIA_ENCODED_AUDIO:
  78                                 priority = B_AUDIO_RECORDING;
  79                                 break;
  80
  81                         case B_MEDIA_RAW_VIDEO:
  82                         case B_MEDIA_ENCODED_VIDEO:
  83                                 priority = B_VIDEO_RECORDING;
  84                                 break;
  85
  86                         default:
  87                                 priority = B_DEFAULT_MEDIA_PRIORITY;
  88                 }
  89         }
  90
  91         SetPriority(suggest_thread_priority(priority));
  92         BMediaNode::SetRunMode(mode);
  93 }
  94
  95
  96 void
  97 BMediaClientNode::Start(bigtime_t performanceTime)
  98 {
  99         CALLED();
 100
 101         BMediaEventLooper::Start(performanceTime);
 102 }
 103
 104
 105 void
 106 BMediaClientNode::Stop(bigtime_t performanceTime, bool immediate)
 107 {
 108         CALLED();
 109
 110         BMediaEventLooper::Stop(performanceTime, immediate);
 111 }
 112
 113
 114 void
 115 BMediaClientNode::Seek(bigtime_t mediaTime, bigtime_t performanceTime)
 116 {
 117         CALLED();
 118
 119         BMediaEventLooper::Seek(mediaTime, performanceTime);
 120 }
 121
 122
 123 void
 124 BMediaClientNode::TimeWarp(bigtime_t realTime, bigtime_t performanceTime)
 125 {
 126         CALLED();
 127
 128         BMediaEventLooper::TimeWarp(realTime, performanceTime);
 129 }
 130
 131
 132 status_t
 133 BMediaClientNode::HandleMessage(int32 message,
 134         const void* data, size_t size)
 135 {
 136         CALLED();
 137
 138         return B_ERROR;
 139 }
 140
 141
 142 status_t
 143 BMediaClientNode::AcceptFormat(const media_destination& dest,
 144         media_format* format)
 145 {
 146         CALLED();
 147
 148         BMediaInput* conn = fOwner->_FindInput(dest);
 149         if (conn == NULL)
 150                 return B_MEDIA_BAD_DESTINATION;
 151
 152         if (format_is_compatible(*format, conn->AcceptedFormat()))
 153                 return B_OK;
 154
 155         *format = conn->AcceptedFormat();
 156
 157         return B_MEDIA_BAD_FORMAT;
 158 }
 159
 160
 161 status_t
 162 BMediaClientNode::GetNextInput(int32* cookie,
 163         media_input* input)
 164 {
 165         CALLED();
 166
 167         if (fOwner->CountInputs() == 0)
 168                 return B_BAD_INDEX;
 169
 170         if (*cookie < 0 || *cookie >= fOwner->CountInputs()) {
 171                 *cookie = -1;
 172                 input = NULL;
 173         } else {
 174                 BMediaInput* conn = fOwner->InputAt(*cookie);
 175                 if (conn != NULL) {
 176                         *input = conn->_MediaInput();
 177                         *cookie += 1;
 178                         return B_OK;
 179                 }
 180         }
 181         return B_BAD_INDEX;
 182 }
 183
 184
 185 void
 186 BMediaClientNode::DisposeInputCookie(int32 cookie)
 187 {
 188         CALLED();
 189 }
 190
 191
 192 void
 193 BMediaClientNode::BufferReceived(BBuffer* buffer)
 194 {
 195         CALLED();
 196
 197         EventQueue()->AddEvent(media_timed_event(buffer->Header()->start_time,
 198                 BTimedEventQueue::B_HANDLE_BUFFER, buffer,
 199                 BTimedEventQueue::B_RECYCLE_BUFFER));
 200 }
 201
 202
 203 status_t
 204 BMediaClientNode::GetLatencyFor(const media_destination& dest,
 205         bigtime_t* latency, media_node_id* timesource)
 206 {
 207         CALLED();
 208
 209         BMediaInput* conn = fOwner->_FindInput(dest);
 210         if (conn == NULL)
 211                 return B_MEDIA_BAD_DESTINATION;
 212
 213         *latency = conn->fMaxLatency;
 214         *timesource = TimeSource()->ID();
 215         return B_OK;
 216 }
 217
 218
 219 status_t
 220 BMediaClientNode::Connected(const media_source& source,
 221         const media_destination& dest, const media_format& format,
 222         media_input* outInput)
 223 {
 224         CALLED();
 225
 226         BMediaInput* conn = fOwner->_FindInput(dest);
 227         if (conn == NULL)
 228                 return B_MEDIA_BAD_DESTINATION;
 229
 230         conn->fConnection.source = source;
 231         conn->SetAcceptedFormat(format);
 232
 233         conn->Connected(format);
 234
 235         *outInput = conn->_MediaInput();
 236         return B_OK;
 237 }
 238
 239
 240 void
 241 BMediaClientNode::Disconnected(const media_source& source,
 242         const media_destination& dest)
 243 {
 244         CALLED();
 245
 246         BMediaInput* conn = fOwner->_FindInput(dest);
 247         if (conn == NULL)
 248                 return;
 249
 250         if (conn->_Source() == source) {
 251                 conn->Disconnect();
 252                 conn->Disconnected();
 253         }
 254 }
 255
 256
 257 status_t
 258 BMediaClientNode::FormatChanged(const media_source& source,
 259         const media_destination& dest,
 260         int32 tag, const media_format& format)
 261 {
 262         CALLED();
 263
 264         BMediaInput* conn = fOwner->_FindInput(dest);
 265         if (conn == NULL)
 266                 return B_MEDIA_BAD_DESTINATION;
 267
 268         return conn->FormatChanged(format);
 269 }
 270
 271
 272 status_t
 273 BMediaClientNode::FormatSuggestionRequested(media_type type,
 274         int32 quality, media_format* format)
 275 {
 276         CALLED();
 277
 278         if (type != ConsumerType()
 279                         && type != ProducerType()) {
 280                 return B_MEDIA_BAD_FORMAT;
 281         }
 282
 283         status_t ret = fOwner->FormatSuggestion(type, quality, format);
 284         if (ret != B_OK) {
 285                 // In that case we return just a very generic format.
 286                 media_format outFormat;
 287                 outFormat.type = fOwner->MediaType();
 288                 *format = outFormat;
 289                 return B_OK;
 290         }
 291
 292         return ret;
 293 }
 294
 295
 296 status_t
 297 BMediaClientNode::FormatProposal(const media_source& source,
 298         media_format* format)
 299 {
 300         CALLED();
 301
 302         BMediaOutput* conn = fOwner->_FindOutput(source);
 303         if (conn == NULL)
 304                 return B_MEDIA_BAD_DESTINATION;
 305
 306         return conn->FormatProposal(format);
 307 }
 308
 309
 310 status_t
 311 BMediaClientNode::FormatChangeRequested(const media_source& source,
 312         const media_destination& dest, media_format* format,
 313         int32* _deprecated_)
 314 {
 315         CALLED();
 316
 317         BMediaOutput* conn = fOwner->_FindOutput(source);
 318         if (conn == NULL)
 319                 return B_MEDIA_BAD_DESTINATION;
 320
 321         return conn->FormatChangeRequested(format);
 322 }
 323
 324
 325 void
 326 BMediaClientNode::LateNoticeReceived(const media_source& source,
 327         bigtime_t late, bigtime_t when)
 328 {
 329         CALLED();
 330
 331 }
 332
 333
 334 status_t
 335 BMediaClientNode::GetNextOutput(int32* cookie, media_output* output)
 336 {
 337         CALLED();
 338
 339         if (fOwner->CountOutputs() == 0)
 340                 return B_BAD_INDEX;
 341
 342         if (*cookie < 0 || *cookie >= fOwner->CountOutputs()) {
 343                 *cookie = -1;
 344                 output = NULL;
 345         } else {
 346                 BMediaOutput* conn = fOwner->OutputAt(*cookie);
 347                 if (conn != NULL) {
 348                         *output = conn->_MediaOutput();
 349                         *cookie += 1;
 350                         return B_OK;
 351                 }
 352         }
 353         return B_BAD_INDEX;
 354 }
 355
 356
 357 status_t
 358 BMediaClientNode::DisposeOutputCookie(int32 cookie)
 359 {
 360         CALLED();
 361
 362         return B_OK;
 363 }
 364
 365
 366 status_t
 367 BMediaClientNode::SetBufferGroup(const media_source& source, BBufferGroup* group)
 368 {
 369         CALLED();
 370
 371         BMediaOutput* conn = fOwner->_FindOutput(source);
 372         if (conn == NULL)
 373                 return B_MEDIA_BAD_SOURCE;
 374
 375         if (group == conn->fBufferGroup)
 376                 return B_OK;
 377
 378         delete conn->fBufferGroup;
 379
 380         if (group != NULL) {
 381                 conn->fBufferGroup = group;
 382                 return B_OK;
 383         }
 384
 385         conn->fBufferGroup = new BBufferGroup(conn->BufferSize(), 3);
 386         if (conn->fBufferGroup == NULL)
 387                 return B_NO_MEMORY;
 388
 389         return conn->fBufferGroup->InitCheck();
 390 }
 391
 392
 393 status_t
 394 BMediaClientNode::PrepareToConnect(const media_source& source,
 395         const media_destination& dest, media_format* format,
 396         media_source* out_source, char *name)
 397 {
 398         CALLED();
 399
 400         BMediaOutput* conn = fOwner->_FindOutput(source);
 401         if (conn == NULL)
 402                 return B_MEDIA_BAD_SOURCE;
 403
 404         if (conn->_Destination() != media_destination::null)
 405                 return B_MEDIA_ALREADY_CONNECTED;
 406
 407         if (fOwner->MediaType() != B_MEDIA_UNKNOWN_TYPE
 408                         && format->type != fOwner->MediaType()) {
 409                 return B_MEDIA_BAD_FORMAT;
 410         }
 411
 412         conn->fConnection.destination = dest;
 413
 414         status_t err = conn->PrepareToConnect(format);
 415         if (err != B_OK)
 416                 return err;
 417
 418         *out_source = conn->_Source();
 419         strcpy(name, Name());
 420
 421         return B_OK;
 422 }
 423
 424
 425 void
 426 BMediaClientNode::Connect(status_t status, const media_source& source,
 427         const media_destination& dest, const media_format& format,
 428         char* name)
 429 {
 430         CALLED();
 431
 432         BMediaOutput* conn = fOwner->_FindOutput(source);
 433         if (conn == NULL)
 434                 return;
 435
 436         // Reset the connection to reuse it
 437         if (status != B_OK) {
 438                 conn->Disconnect();
 439                 return;
 440         }
 441
 442         conn->fConnection.destination = dest;
 443         conn->SetAcceptedFormat(format);
 444         strcpy(name, Name());
 445
 446         // TODO: add correct latency estimate
 447         SetEventLatency(1000);
 448
 449         conn->fBufferGroup = new BBufferGroup(conn->BufferSize(), 3);
 450         if (conn->fBufferGroup == NULL)
 451                 TRACE("Can't allocate the buffer group\n");
 452
 453         conn->Connected(format);
 454 }
 455
 456
 457 void
 458 BMediaClientNode::Disconnect(const media_source& source,
 459         const media_destination& dest)
 460 {
 461         CALLED();
 462
 463         BMediaOutput* conn = fOwner->_FindOutput(source);
 464         if (conn == NULL)
 465                 return;
 466
 467         if (conn->_Destination() == dest) {
 468                 conn->Disconnect();
 469                 conn->Disconnected();
 470         }
 471 }
 472
 473
 474 void
 475 BMediaClientNode::EnableOutput(const media_source& source,
 476         bool enabled, int32* _deprecated_)
 477 {
 478         CALLED();
 479
 480         BMediaOutput* conn = fOwner->_FindOutput(source);
 481         if (conn != NULL)
 482                 conn->SetEnabled(enabled);
 483 }
 484
 485
 486 status_t
 487 BMediaClientNode::GetLatency(bigtime_t* outLatency)
 488 {
 489         CALLED();
 490
 491         // TODO: finish latency handling
 492         *outLatency = 1000;
 493         return B_OK;
 494 }
 495
 496
 497 void
 498 BMediaClientNode::LatencyChanged(const media_source& source,
 499         const media_destination& dest, bigtime_t latency, uint32 flags)
 500 {
 501         CALLED();
 502 }
 503
 504
 505 void
 506 BMediaClientNode::ProducerDataStatus(const media_destination& dest,
 507         int32 status, bigtime_t when)
 508 {
 509         CALLED();
 510 }
 511
 512
 513 void
 514 BMediaClientNode::HandleEvent(const media_timed_event* event,
 515         bigtime_t late, bool realTimeEvent)
 516 {
 517         CALLED();
 518
 519         switch (event->type) {
 520                 // This event is used for inputs which consumes buffers
 521                 // or binded connections which also send them to an output.
 522                 case BTimedEventQueue::B_HANDLE_BUFFER:
 523                         _HandleBuffer((BBuffer*)event->pointer);
 524                         break;
 525
 526                 // This is used for connections which produce buffers only.
 527                 case B_NEW_BUFFER:
 528                         _ProduceNewBuffer(event, late);
 529                         break;
 530
 531                 case BTimedEventQueue::B_START:
 532                 {
 533                         if (RunState() != B_STARTED)
 534                                 fOwner->HandleStart(event->event_time);
 535
 536                         fStartTime = event->event_time;
 537
 538                         _ScheduleConnections(event->event_time);
 539                         break;
 540                 }
 541
 542                 case BTimedEventQueue::B_STOP:
 543                 {
 544                         fOwner->HandleStop(event->event_time);
 545
 546                         EventQueue()->FlushEvents(0, BTimedEventQueue::B_ALWAYS, true,
 547                                 BTimedEventQueue::B_HANDLE_BUFFER);
 548                         break;
 549                 }
 550
 551                 case BTimedEventQueue::B_SEEK:
 552                         fOwner->HandleSeek(event->event_time, event->bigdata);
 553                         break;
 554
 555                 case BTimedEventQueue::B_WARP:
 556                         // NOTE: We have no need to handle it
 557                         break;
 558         }
 559 }
 560
 561
 562 BMediaClientNode::~BMediaClientNode()
 563 {
 564         CALLED();
 565
 566         Quit();
 567 }
 568
 569
 570 void
 571 BMediaClientNode::_ScheduleConnections(bigtime_t eventTime)
 572 {
 573         for (int32 i = 0; i < fOwner->CountOutputs(); i++) {
 574                 BMediaOutput* output = fOwner->OutputAt(i);
 575
 576                 if (output->HasBinding())
 577                         continue;
 578
 579                 media_timed_event firstBufferEvent(eventTime,
 580                         B_NEW_BUFFER);
 581
 582                 output->fFramesSent = 0;
 583
 584                 firstBufferEvent.pointer = (void*) output;
 585                 EventQueue()->AddEvent(firstBufferEvent);
 586         }
 587 }
 588
 589
 590 void
 591 BMediaClientNode::_HandleBuffer(BBuffer* buffer)
 592 {
 593         CALLED();
 594
 595         media_destination dest;
 596         dest.id = buffer->Header()->destination;
 597         BMediaInput* conn = fOwner->_FindInput(dest);
 598
 599         if (conn != NULL)
 600                 conn->HandleBuffer(buffer);
 601
 602         // TODO: Investigate system level latency logging
 603
 604         if (conn->HasBinding()) {
 605                 BMediaOutput* output = dynamic_cast<BMediaOutput*>(conn->Binding());
 606                 output->SendBuffer(buffer);
 607         }
 608 }
 609
 610
 611 void
 612 BMediaClientNode::_ProduceNewBuffer(const media_timed_event* event,
 613         bigtime_t late)
 614 {
 615         CALLED();
 616
 617         if (RunState() != BMediaEventLooper::B_STARTED)
 618                 return;
 619
 620         // The connection is get through the event
 621         BMediaOutput* output
 622                 = dynamic_cast<BMediaOutput*>((BMediaConnection*)event->pointer);
 623         if (output == NULL)
 624                 return;
 625
 626         if (output->IsEnabled()) {
 627                 BBuffer* buffer = _GetNextBuffer(output, event->event_time);
 628
 629                 if (buffer != NULL) {
 630                         if (output->SendBuffer(buffer) != B_OK) {
 631                                 TRACE("BMediaClientNode: Failed to send buffer\n");
 632                                 // The output failed, let's recycle the buffer
 633                                 buffer->Recycle();
 634                         }
 635                 }
 636         }
 637
 638         bigtime_t time = 0;
 639         media_format format = output->AcceptedFormat();
 640         if (format.IsAudio()) {
 641                 size_t nFrames = format.u.raw_audio.buffer_size
 642                         / ((format.u.raw_audio.format
 643                                 & media_raw_audio_format::B_AUDIO_SIZE_MASK)
 644                         * format.u.raw_audio.channel_count);
 645                 output->fFramesSent += nFrames;
 646
 647                 time = fStartTime + bigtime_t((1000000LL * output->fFramesSent)
 648                         / (int32)format.u.raw_audio.frame_rate);
 649         }
 650
 651         media_timed_event nextEvent(time, B_NEW_BUFFER);
 652         EventQueue()->AddEvent(nextEvent);
 653 }
 654
 655
 656 BBuffer*
 657 BMediaClientNode::_GetNextBuffer(BMediaOutput* output, bigtime_t eventTime)
 658 {
 659         CALLED();
 660
 661         BBuffer* buffer = NULL;
 662         if (output->fBufferGroup->RequestBuffer(buffer, 0) != B_OK) {
 663                 TRACE("MediaClientNode:::_GetNextBuffer: Failed to get the buffer\n");
 664                 return NULL;
 665         }
 666
 667         media_header* header = buffer->Header();
 668         header->type = output->AcceptedFormat().type;
 669         header->size_used = output->BufferSize();
 670         header->time_source = TimeSource()->ID();
 671         header->start_time = eventTime;
 672
 673         return buffer;
 674 }