1 /* 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #include <assert.h> 12 13 #include "webrtc/engine_configurations.h" 14 #include "webrtc/modules/video_render/external/video_render_external_impl.h" 15 #include "webrtc/modules/video_render/include/video_render_defines.h" 16 #include "webrtc/modules/video_render/incoming_video_stream.h" 17 #include "webrtc/modules/video_render/i_video_render.h" 18 #include "webrtc/modules/video_render/video_render_impl.h" 19 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h" 20 #include "webrtc/system_wrappers/interface/trace.h" 21 22 namespace webrtc { 23 24 VideoRender* 25 VideoRender::CreateVideoRender(const int32_t id, 26 void* window, 27 const bool fullscreen, 28 const VideoRenderType videoRenderType/*=kRenderDefault*/) 29 { 30 VideoRenderType resultVideoRenderType = videoRenderType; 31 if (videoRenderType == kRenderDefault) 32 { 33 resultVideoRenderType = kRenderExternal; 34 } 35 return new ModuleVideoRenderImpl(id, resultVideoRenderType, window, 36 fullscreen); 37 } 38 39 void VideoRender::DestroyVideoRender( 40 VideoRender* module) 41 { 42 if (module) 43 { 44 delete module; 45 } 46 } 47 48 ModuleVideoRenderImpl::ModuleVideoRenderImpl( 49 const int32_t id, 50 const VideoRenderType videoRenderType, 51 void* window, 52 const bool fullscreen) : 53 _id(id), _moduleCrit(*CriticalSectionWrapper::CreateCriticalSection()), 54 _ptrWindow(window), _fullScreen(fullscreen), _ptrRenderer(NULL) 55 { 56 57 // Create platform specific renderer 58 switch (videoRenderType) 59 { 60 case kRenderExternal: 61 { 62 VideoRenderExternalImpl* ptrRenderer(NULL); 63 ptrRenderer = new VideoRenderExternalImpl(_id, videoRenderType, 64 window, _fullScreen); 65 if (ptrRenderer) 66 { 67 _ptrRenderer = reinterpret_cast<IVideoRender*> (ptrRenderer); 68 } 69 } 70 break; 71 default: 72 // Error... 73 break; 74 } 75 if (_ptrRenderer) 76 { 77 if (_ptrRenderer->Init() == -1) 78 { 79 } 80 } 81 } 82 83 ModuleVideoRenderImpl::~ModuleVideoRenderImpl() 84 { 85 delete &_moduleCrit; 86 87 for (IncomingVideoStreamMap::iterator it = _streamRenderMap.begin(); 88 it != _streamRenderMap.end(); 89 ++it) { 90 delete it->second; 91 } 92 93 // Delete platform specific renderer 94 if (_ptrRenderer) 95 { 96 VideoRenderType videoRenderType = _ptrRenderer->RenderType(); 97 98 switch (videoRenderType) 99 { 100 case kRenderExternal: 101 { 102 VideoRenderExternalImpl 103 * ptrRenderer = 104 reinterpret_cast<VideoRenderExternalImpl*> (_ptrRenderer); 105 _ptrRenderer = NULL; 106 delete ptrRenderer; 107 } 108 break; 109 110 default: 111 // Error... 112 break; 113 } 114 } 115 } 116 117 int32_t ModuleVideoRenderImpl::ChangeUniqueId(const int32_t id) 118 { 119 120 CriticalSectionScoped cs(&_moduleCrit); 121 122 _id = id; 123 124 if (_ptrRenderer) 125 { 126 _ptrRenderer->ChangeUniqueId(_id); 127 } 128 129 return 0; 130 } 131 132 int32_t ModuleVideoRenderImpl::TimeUntilNextProcess() 133 { 134 // Not used 135 return 50; 136 } 137 int32_t ModuleVideoRenderImpl::Process() 138 { 139 // Not used 140 return 0; 141 } 142 143 void* 144 ModuleVideoRenderImpl::Window() 145 { 146 CriticalSectionScoped cs(&_moduleCrit); 147 return _ptrWindow; 148 } 149 150 int32_t ModuleVideoRenderImpl::ChangeWindow(void* window) 151 { 152 return -1; 153 } 154 155 int32_t ModuleVideoRenderImpl::Id() 156 { 157 CriticalSectionScoped cs(&_moduleCrit); 158 return _id; 159 } 160 161 uint32_t ModuleVideoRenderImpl::GetIncomingFrameRate(const uint32_t streamId) { 162 CriticalSectionScoped cs(&_moduleCrit); 163 164 IncomingVideoStreamMap::iterator it = _streamRenderMap.find(streamId); 165 166 if (it == _streamRenderMap.end()) { 167 // This stream doesn't exist 168 WEBRTC_TRACE(kTraceError, 169 kTraceVideoRenderer, 170 _id, 171 "%s: stream doesn't exist", 172 __FUNCTION__); 173 return 0; 174 } 175 assert(it->second != NULL); 176 return it->second->IncomingRate(); 177 } 178 179 VideoRenderCallback* 180 ModuleVideoRenderImpl::AddIncomingRenderStream(const uint32_t streamId, 181 const uint32_t zOrder, 182 const float left, 183 const float top, 184 const float right, 185 const float bottom) 186 { 187 CriticalSectionScoped cs(&_moduleCrit); 188 189 if (!_ptrRenderer) 190 { 191 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 192 "%s: No renderer", __FUNCTION__); 193 return NULL; 194 } 195 196 if (_streamRenderMap.find(streamId) != _streamRenderMap.end()) { 197 // The stream already exists... 198 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 199 "%s: stream already exists", __FUNCTION__); 200 return NULL; 201 } 202 203 VideoRenderCallback* ptrRenderCallback = 204 _ptrRenderer->AddIncomingRenderStream(streamId, zOrder, left, top, 205 right, bottom); 206 if (ptrRenderCallback == NULL) 207 { 208 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 209 "%s: Can't create incoming stream in renderer", 210 __FUNCTION__); 211 return NULL; 212 } 213 214 // Create platform independant code 215 IncomingVideoStream* ptrIncomingStream = new IncomingVideoStream(_id, 216 streamId); 217 if (ptrIncomingStream == NULL) 218 { 219 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 220 "%s: Can't create incoming stream", __FUNCTION__); 221 return NULL; 222 } 223 224 225 if (ptrIncomingStream->SetRenderCallback(ptrRenderCallback) == -1) 226 { 227 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 228 "%s: Can't set render callback", __FUNCTION__); 229 delete ptrIncomingStream; 230 _ptrRenderer->DeleteIncomingRenderStream(streamId); 231 return NULL; 232 } 233 234 VideoRenderCallback* moduleCallback = 235 ptrIncomingStream->ModuleCallback(); 236 237 // Store the stream 238 _streamRenderMap[streamId] = ptrIncomingStream; 239 240 return moduleCallback; 241 } 242 243 int32_t ModuleVideoRenderImpl::DeleteIncomingRenderStream( 244 const uint32_t streamId) 245 { 246 CriticalSectionScoped cs(&_moduleCrit); 247 248 if (!_ptrRenderer) 249 { 250 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 251 "%s: No renderer", __FUNCTION__); 252 return -1; 253 } 254 255 IncomingVideoStreamMap::iterator item = _streamRenderMap.find(streamId); 256 if (item == _streamRenderMap.end()) 257 { 258 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 259 "%s: stream doesn't exist", __FUNCTION__); 260 return -1; 261 } 262 263 delete item->second; 264 265 _ptrRenderer->DeleteIncomingRenderStream(streamId); 266 267 _streamRenderMap.erase(item); 268 269 return 0; 270 } 271 272 int32_t ModuleVideoRenderImpl::AddExternalRenderCallback( 273 const uint32_t streamId, 274 VideoRenderCallback* renderObject) { 275 CriticalSectionScoped cs(&_moduleCrit); 276 277 IncomingVideoStreamMap::iterator item = _streamRenderMap.find(streamId); 278 279 if (item == _streamRenderMap.end()) 280 { 281 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 282 "%s: stream doesn't exist", __FUNCTION__); 283 return -1; 284 } 285 286 if (item->second == NULL) { 287 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 288 "%s: could not get stream", __FUNCTION__); 289 return -1; 290 } 291 return item->second->SetExternalCallback(renderObject); 292 } 293 294 int32_t ModuleVideoRenderImpl::GetIncomingRenderStreamProperties( 295 const uint32_t streamId, 296 uint32_t& zOrder, 297 float& left, 298 float& top, 299 float& right, 300 float& bottom) const { 301 CriticalSectionScoped cs(&_moduleCrit); 302 303 if (!_ptrRenderer) 304 { 305 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 306 "%s: No renderer", __FUNCTION__); 307 return -1; 308 } 309 310 return _ptrRenderer->GetIncomingRenderStreamProperties(streamId, zOrder, 311 left, top, right, 312 bottom); 313 } 314 315 uint32_t ModuleVideoRenderImpl::GetNumIncomingRenderStreams() const 316 { 317 CriticalSectionScoped cs(&_moduleCrit); 318 319 return static_cast<uint32_t>(_streamRenderMap.size()); 320 } 321 322 bool ModuleVideoRenderImpl::HasIncomingRenderStream( 323 const uint32_t streamId) const { 324 CriticalSectionScoped cs(&_moduleCrit); 325 326 return _streamRenderMap.find(streamId) != _streamRenderMap.end(); 327 } 328 329 int32_t ModuleVideoRenderImpl::RegisterRawFrameCallback( 330 const uint32_t streamId, 331 VideoRenderCallback* callbackObj) { 332 return -1; 333 } 334 335 int32_t ModuleVideoRenderImpl::StartRender(const uint32_t streamId) 336 { 337 CriticalSectionScoped cs(&_moduleCrit); 338 339 if (!_ptrRenderer) 340 { 341 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 342 "%s: No renderer", __FUNCTION__); 343 return -1; 344 } 345 346 // Start the stream 347 IncomingVideoStreamMap::iterator item = _streamRenderMap.find(streamId); 348 349 if (item == _streamRenderMap.end()) 350 { 351 return -1; 352 } 353 354 if (item->second->Start() == -1) 355 { 356 return -1; 357 } 358 359 // Start the HW renderer 360 if (_ptrRenderer->StartRender() == -1) 361 { 362 return -1; 363 } 364 return 0; 365 } 366 367 int32_t ModuleVideoRenderImpl::StopRender(const uint32_t streamId) 368 { 369 CriticalSectionScoped cs(&_moduleCrit); 370 371 if (!_ptrRenderer) 372 { 373 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 374 "%s(%d): No renderer", __FUNCTION__, streamId); 375 return -1; 376 } 377 378 // Stop the incoming stream 379 IncomingVideoStreamMap::iterator item = _streamRenderMap.find(streamId); 380 381 if (item == _streamRenderMap.end()) 382 { 383 return -1; 384 } 385 386 if (item->second->Stop() == -1) 387 { 388 return -1; 389 } 390 391 return 0; 392 } 393 394 int32_t ModuleVideoRenderImpl::ResetRender() 395 { 396 CriticalSectionScoped cs(&_moduleCrit); 397 398 int32_t ret = 0; 399 // Loop through all incoming streams and reset them 400 for (IncomingVideoStreamMap::iterator it = _streamRenderMap.begin(); 401 it != _streamRenderMap.end(); 402 ++it) { 403 if (it->second->Reset() == -1) 404 ret = -1; 405 } 406 return ret; 407 } 408 409 RawVideoType ModuleVideoRenderImpl::PreferredVideoType() const 410 { 411 CriticalSectionScoped cs(&_moduleCrit); 412 413 if (_ptrRenderer == NULL) 414 { 415 return kVideoI420; 416 } 417 418 return _ptrRenderer->PerferedVideoType(); 419 } 420 421 bool ModuleVideoRenderImpl::IsFullScreen() 422 { 423 CriticalSectionScoped cs(&_moduleCrit); 424 425 if (!_ptrRenderer) 426 { 427 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 428 "%s: No renderer", __FUNCTION__); 429 return false; 430 } 431 return _ptrRenderer->FullScreen(); 432 } 433 434 int32_t ModuleVideoRenderImpl::GetScreenResolution( 435 uint32_t& screenWidth, 436 uint32_t& screenHeight) const 437 { 438 CriticalSectionScoped cs(&_moduleCrit); 439 440 if (!_ptrRenderer) 441 { 442 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 443 "%s: No renderer", __FUNCTION__); 444 return false; 445 } 446 return _ptrRenderer->GetScreenResolution(screenWidth, screenHeight); 447 } 448 449 uint32_t ModuleVideoRenderImpl::RenderFrameRate( 450 const uint32_t streamId) 451 { 452 CriticalSectionScoped cs(&_moduleCrit); 453 454 if (!_ptrRenderer) 455 { 456 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 457 "%s: No renderer", __FUNCTION__); 458 return false; 459 } 460 return _ptrRenderer->RenderFrameRate(streamId); 461 } 462 463 int32_t ModuleVideoRenderImpl::SetStreamCropping( 464 const uint32_t streamId, 465 const float left, 466 const float top, 467 const float right, 468 const float bottom) 469 { 470 CriticalSectionScoped cs(&_moduleCrit); 471 472 if (!_ptrRenderer) 473 { 474 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 475 "%s: No renderer", __FUNCTION__); 476 return false; 477 } 478 return _ptrRenderer->SetStreamCropping(streamId, left, top, right, bottom); 479 } 480 481 int32_t ModuleVideoRenderImpl::SetTransparentBackground(const bool enable) 482 { 483 CriticalSectionScoped cs(&_moduleCrit); 484 485 if (!_ptrRenderer) 486 { 487 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 488 "%s: No renderer", __FUNCTION__); 489 return false; 490 } 491 return _ptrRenderer->SetTransparentBackground(enable); 492 } 493 494 int32_t ModuleVideoRenderImpl::FullScreenRender(void* window, const bool enable) 495 { 496 return -1; 497 } 498 499 int32_t ModuleVideoRenderImpl::SetText( 500 const uint8_t textId, 501 const uint8_t* text, 502 const int32_t textLength, 503 const uint32_t textColorRef, 504 const uint32_t backgroundColorRef, 505 const float left, const float top, 506 const float right, 507 const float bottom) 508 { 509 CriticalSectionScoped cs(&_moduleCrit); 510 511 if (!_ptrRenderer) 512 { 513 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 514 "%s: No renderer", __FUNCTION__); 515 return -1; 516 } 517 return _ptrRenderer->SetText(textId, text, textLength, textColorRef, 518 backgroundColorRef, left, top, right, bottom); 519 } 520 521 int32_t ModuleVideoRenderImpl::SetBitmap(const void* bitMap, 522 const uint8_t pictureId, 523 const void* colorKey, 524 const float left, 525 const float top, 526 const float right, 527 const float bottom) 528 { 529 CriticalSectionScoped cs(&_moduleCrit); 530 531 if (!_ptrRenderer) 532 { 533 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 534 "%s: No renderer", __FUNCTION__); 535 return -1; 536 } 537 return _ptrRenderer->SetBitmap(bitMap, pictureId, colorKey, left, top, 538 right, bottom); 539 } 540 541 int32_t ModuleVideoRenderImpl::GetLastRenderedFrame( 542 const uint32_t streamId, 543 I420VideoFrame &frame) const 544 { 545 CriticalSectionScoped cs(&_moduleCrit); 546 547 if (!_ptrRenderer) 548 { 549 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 550 "%s: No renderer", __FUNCTION__); 551 return -1; 552 } 553 554 IncomingVideoStreamMap::const_iterator item = 555 _streamRenderMap.find(streamId); 556 if (item == _streamRenderMap.end()) 557 { 558 // This stream doesn't exist 559 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 560 "%s: stream doesn't exist", __FUNCTION__); 561 return 0; 562 } 563 564 assert(item->second != NULL); 565 return item->second->GetLastRenderedFrame(frame); 566 } 567 568 int32_t ModuleVideoRenderImpl::SetExpectedRenderDelay( 569 uint32_t stream_id, int32_t delay_ms) { 570 CriticalSectionScoped cs(&_moduleCrit); 571 572 if (!_ptrRenderer) { 573 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 574 "%s: No renderer", __FUNCTION__); 575 return false; 576 } 577 578 IncomingVideoStreamMap::const_iterator item = 579 _streamRenderMap.find(stream_id); 580 if (item == _streamRenderMap.end()) { 581 // This stream doesn't exist 582 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 583 "%s(%u, %d): stream doesn't exist", __FUNCTION__, stream_id, 584 delay_ms); 585 return -1; 586 } 587 588 assert(item->second != NULL); 589 return item->second->SetExpectedRenderDelay(delay_ms); 590 } 591 592 int32_t ModuleVideoRenderImpl::ConfigureRenderer( 593 const uint32_t streamId, 594 const unsigned int zOrder, 595 const float left, 596 const float top, 597 const float right, 598 const float bottom) 599 { 600 CriticalSectionScoped cs(&_moduleCrit); 601 602 if (!_ptrRenderer) 603 { 604 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 605 "%s: No renderer", __FUNCTION__); 606 return false; 607 } 608 return _ptrRenderer->ConfigureRenderer(streamId, zOrder, left, top, right, 609 bottom); 610 } 611 612 int32_t ModuleVideoRenderImpl::SetStartImage( 613 const uint32_t streamId, 614 const I420VideoFrame& videoFrame) 615 { 616 CriticalSectionScoped cs(&_moduleCrit); 617 618 if (!_ptrRenderer) 619 { 620 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 621 "%s: No renderer", __FUNCTION__); 622 return -1; 623 } 624 625 IncomingVideoStreamMap::const_iterator item = 626 _streamRenderMap.find(streamId); 627 if (item == _streamRenderMap.end()) 628 { 629 // This stream doesn't exist 630 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 631 "%s: stream doesn't exist", __FUNCTION__); 632 return -1; 633 } 634 assert (item->second != NULL); 635 return item->second->SetStartImage(videoFrame); 636 637 } 638 639 int32_t ModuleVideoRenderImpl::SetTimeoutImage( 640 const uint32_t streamId, 641 const I420VideoFrame& videoFrame, 642 const uint32_t timeout) 643 { 644 CriticalSectionScoped cs(&_moduleCrit); 645 646 if (!_ptrRenderer) 647 { 648 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 649 "%s: No renderer", __FUNCTION__); 650 return -1; 651 } 652 653 IncomingVideoStreamMap::const_iterator item = 654 _streamRenderMap.find(streamId); 655 if (item == _streamRenderMap.end()) 656 { 657 // This stream doesn't exist 658 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 659 "%s: stream doesn't exist", __FUNCTION__); 660 return -1; 661 } 662 assert(item->second != NULL); 663 return item->second->SetTimeoutImage(videoFrame, timeout); 664 } 665 666 int32_t ModuleVideoRenderImpl::MirrorRenderStream(const int renderId, 667 const bool enable, 668 const bool mirrorXAxis, 669 const bool mirrorYAxis) 670 { 671 CriticalSectionScoped cs(&_moduleCrit); 672 673 if (!_ptrRenderer) 674 { 675 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 676 "%s: No renderer", __FUNCTION__); 677 return -1; 678 } 679 680 IncomingVideoStreamMap::const_iterator item = 681 _streamRenderMap.find(renderId); 682 if (item == _streamRenderMap.end()) 683 { 684 // This stream doesn't exist 685 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, 686 "%s: stream doesn't exist", __FUNCTION__); 687 return 0; 688 } 689 assert(item->second != NULL); 690 691 return item->second->EnableMirroring(enable, mirrorXAxis, mirrorYAxis); 692 } 693 694 } // namespace webrtc 695
