OLD | NEW |
| (Empty) |
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/common_video/include/incoming_video_stream.h" | |
14 #include "webrtc/engine_configurations.h" | |
15 #include "webrtc/modules/video_render/i_video_render.h" | |
16 #include "webrtc/modules/video_render/video_render_defines.h" | |
17 #include "webrtc/modules/video_render/video_render_impl.h" | |
18 #include "webrtc/system_wrappers/include/critical_section_wrapper.h" | |
19 #include "webrtc/system_wrappers/include/trace.h" | |
20 | |
21 #if defined (_WIN32) | |
22 #include "webrtc/modules/video_render/windows/video_render_windows_impl.h" | |
23 #define STANDARD_RENDERING kRenderWindows | |
24 | |
25 // WEBRTC_IOS should go before WEBRTC_MAC because WEBRTC_MAC | |
26 // gets defined if WEBRTC_IOS is defined | |
27 #elif defined(WEBRTC_IOS) | |
28 #define STANDARD_RENDERING kRenderiOS | |
29 #include "webrtc/modules/video_render/ios/video_render_ios_impl.h" | |
30 #elif defined(WEBRTC_MAC) | |
31 #if defined(COCOA_RENDERING) | |
32 #define STANDARD_RENDERING kRenderCocoa | |
33 #include "webrtc/modules/video_render/mac/video_render_mac_cocoa_impl.h" | |
34 #elif defined(CARBON_RENDERING) | |
35 #define STANDARD_RENDERING kRenderCarbon | |
36 #include "webrtc/modules/video_render/mac/video_render_mac_carbon_impl.h" | |
37 #endif | |
38 | |
39 #elif defined(WEBRTC_ANDROID) | |
40 #include "webrtc/modules/video_render/android/video_render_android_impl.h" | |
41 #include "webrtc/modules/video_render/android/video_render_android_native_opengl
2.h" | |
42 #include "webrtc/modules/video_render/android/video_render_android_surface_view.
h" | |
43 #define STANDARD_RENDERING kRenderAndroid | |
44 | |
45 #elif defined(WEBRTC_LINUX) | |
46 #include "webrtc/modules/video_render/linux/video_render_linux_impl.h" | |
47 #define STANDARD_RENDERING kRenderX11 | |
48 | |
49 #else | |
50 //Other platforms | |
51 #endif | |
52 | |
53 // For external rendering | |
54 #include "webrtc/modules/video_render/external/video_render_external_impl.h" | |
55 #ifndef STANDARD_RENDERING | |
56 #define STANDARD_RENDERING kRenderExternal | |
57 #endif // STANDARD_RENDERING | |
58 | |
59 namespace webrtc { | |
60 | |
61 VideoRender* | |
62 VideoRender::CreateVideoRender(const int32_t id, | |
63 void* window, | |
64 const bool fullscreen, | |
65 const VideoRenderType videoRenderType/*=kRenderDe
fault*/) | |
66 { | |
67 VideoRenderType resultVideoRenderType = videoRenderType; | |
68 if (videoRenderType == kRenderDefault) | |
69 { | |
70 resultVideoRenderType = STANDARD_RENDERING; | |
71 } | |
72 return new ModuleVideoRenderImpl(id, resultVideoRenderType, window, | |
73 fullscreen); | |
74 } | |
75 | |
76 void VideoRender::DestroyVideoRender( | |
77 VideoRender* module) | |
78 { | |
79 if (module) | |
80 { | |
81 delete module; | |
82 } | |
83 } | |
84 | |
85 ModuleVideoRenderImpl::ModuleVideoRenderImpl( | |
86 const int32_t id, | |
87 const VideoRenderType videoRenderTy
pe, | |
88 void* window, | |
89 const bool fullscreen) : | |
90 _id(id), _moduleCrit(*CriticalSectionWrapper::CreateCriticalSection()), | |
91 _ptrWindow(window), _fullScreen(fullscreen), _ptrRenderer(NULL) | |
92 { | |
93 | |
94 // Create platform specific renderer | |
95 switch (videoRenderType) | |
96 { | |
97 #if defined(_WIN32) | |
98 case kRenderWindows: | |
99 { | |
100 VideoRenderWindowsImpl* ptrRenderer; | |
101 ptrRenderer = new VideoRenderWindowsImpl(_id, videoRenderType, windo
w, _fullScreen); | |
102 if (ptrRenderer) | |
103 { | |
104 _ptrRenderer = reinterpret_cast<IVideoRender*>(ptrRenderer); | |
105 } | |
106 } | |
107 break; | |
108 | |
109 #elif defined(WEBRTC_IOS) | |
110 case kRenderiOS: | |
111 { | |
112 VideoRenderIosImpl* ptrRenderer = new VideoRenderIosImpl(_id, window
, _fullScreen); | |
113 if(ptrRenderer) | |
114 { | |
115 _ptrRenderer = reinterpret_cast<IVideoRender*>(ptrRenderer); | |
116 } | |
117 } | |
118 break; | |
119 | |
120 #elif defined(WEBRTC_MAC) | |
121 | |
122 #if defined(COCOA_RENDERING) | |
123 case kRenderCocoa: | |
124 { | |
125 VideoRenderMacCocoaImpl* ptrRenderer = new VideoRenderMacCocoaImpl(_
id, videoRenderType, window, _fullScreen); | |
126 if(ptrRenderer) | |
127 { | |
128 _ptrRenderer = reinterpret_cast<IVideoRender*>(ptrRenderer); | |
129 } | |
130 } | |
131 | |
132 break; | |
133 #elif defined(CARBON_RENDERING) | |
134 case kRenderCarbon: | |
135 { | |
136 VideoRenderMacCarbonImpl* ptrRenderer = new VideoRenderMacCarbonImpl
(_id, videoRenderType, window, _fullScreen); | |
137 if(ptrRenderer) | |
138 { | |
139 _ptrRenderer = reinterpret_cast<IVideoRender*>(ptrRenderer); | |
140 } | |
141 } | |
142 break; | |
143 #endif | |
144 | |
145 #elif defined(WEBRTC_ANDROID) | |
146 case kRenderAndroid: | |
147 { | |
148 if(AndroidNativeOpenGl2Renderer::UseOpenGL2(window)) | |
149 { | |
150 AndroidNativeOpenGl2Renderer* ptrRenderer = NULL; | |
151 ptrRenderer = new AndroidNativeOpenGl2Renderer(_id, videoRenderT
ype, window, _fullScreen); | |
152 if (ptrRenderer) | |
153 { | |
154 _ptrRenderer = reinterpret_cast<IVideoRender*> (ptrRenderer)
; | |
155 } | |
156 } | |
157 else | |
158 { | |
159 AndroidSurfaceViewRenderer* ptrRenderer = NULL; | |
160 ptrRenderer = new AndroidSurfaceViewRenderer(_id, videoRenderTyp
e, window, _fullScreen); | |
161 if (ptrRenderer) | |
162 { | |
163 _ptrRenderer = reinterpret_cast<IVideoRender*> (ptrRenderer)
; | |
164 } | |
165 } | |
166 | |
167 } | |
168 break; | |
169 #elif defined(WEBRTC_LINUX) | |
170 case kRenderX11: | |
171 { | |
172 VideoRenderLinuxImpl* ptrRenderer = NULL; | |
173 ptrRenderer = new VideoRenderLinuxImpl(_id, videoRenderType, window,
_fullScreen); | |
174 if ( ptrRenderer ) | |
175 { | |
176 _ptrRenderer = reinterpret_cast<IVideoRender*> (ptrRenderer); | |
177 } | |
178 } | |
179 break; | |
180 | |
181 #else | |
182 // Other platforms | |
183 #endif | |
184 case kRenderExternal: | |
185 { | |
186 VideoRenderExternalImpl* ptrRenderer(NULL); | |
187 ptrRenderer = new VideoRenderExternalImpl(_id, videoRenderType, | |
188 window, _fullScreen); | |
189 if (ptrRenderer) | |
190 { | |
191 _ptrRenderer = reinterpret_cast<IVideoRender*> (ptrRenderer); | |
192 } | |
193 } | |
194 break; | |
195 default: | |
196 // Error... | |
197 break; | |
198 } | |
199 if (_ptrRenderer) | |
200 { | |
201 if (_ptrRenderer->Init() == -1) | |
202 { | |
203 } | |
204 } | |
205 } | |
206 | |
207 ModuleVideoRenderImpl::~ModuleVideoRenderImpl() | |
208 { | |
209 delete &_moduleCrit; | |
210 | |
211 for (IncomingVideoStreamMap::iterator it = _streamRenderMap.begin(); | |
212 it != _streamRenderMap.end(); | |
213 ++it) { | |
214 delete it->second; | |
215 } | |
216 | |
217 // Delete platform specific renderer | |
218 if (_ptrRenderer) | |
219 { | |
220 VideoRenderType videoRenderType = _ptrRenderer->RenderType(); | |
221 | |
222 switch (videoRenderType) | |
223 { | |
224 case kRenderExternal: | |
225 { | |
226 VideoRenderExternalImpl | |
227 * ptrRenderer = | |
228 reinterpret_cast<VideoRenderExternalImpl*> (_ptr
Renderer); | |
229 _ptrRenderer = NULL; | |
230 delete ptrRenderer; | |
231 } | |
232 break; | |
233 #if defined(_WIN32) | |
234 case kRenderWindows: | |
235 { | |
236 VideoRenderWindowsImpl* ptrRenderer = reinterpret_cast<VideoRend
erWindowsImpl*>(_ptrRenderer); | |
237 _ptrRenderer = NULL; | |
238 delete ptrRenderer; | |
239 } | |
240 break; | |
241 #elif defined(WEBRTC_IOS) | |
242 case kRenderiOS: | |
243 { | |
244 VideoRenderIosImpl* ptrRenderer = reinterpret_cast<VideoRenderIosI
mpl*> (_ptrRenderer); | |
245 _ptrRenderer = NULL; | |
246 delete ptrRenderer; | |
247 } | |
248 break; | |
249 #elif defined(WEBRTC_MAC) | |
250 | |
251 #if defined(COCOA_RENDERING) | |
252 case kRenderCocoa: | |
253 { | |
254 VideoRenderMacCocoaImpl* ptrRenderer = reinterpret_cast<VideoRen
derMacCocoaImpl*> (_ptrRenderer); | |
255 _ptrRenderer = NULL; | |
256 delete ptrRenderer; | |
257 } | |
258 break; | |
259 #elif defined(CARBON_RENDERING) | |
260 case kRenderCarbon: | |
261 { | |
262 VideoRenderMacCarbonImpl* ptrRenderer = reinterpret_cast<VideoRe
nderMacCarbonImpl*> (_ptrRenderer); | |
263 _ptrRenderer = NULL; | |
264 delete ptrRenderer; | |
265 } | |
266 break; | |
267 #endif | |
268 | |
269 #elif defined(WEBRTC_ANDROID) | |
270 case kRenderAndroid: | |
271 { | |
272 VideoRenderAndroid* ptrRenderer = reinterpret_cast<VideoRenderAn
droid*> (_ptrRenderer); | |
273 _ptrRenderer = NULL; | |
274 delete ptrRenderer; | |
275 } | |
276 break; | |
277 | |
278 #elif defined(WEBRTC_LINUX) | |
279 case kRenderX11: | |
280 { | |
281 VideoRenderLinuxImpl* ptrRenderer = reinterpret_cast<VideoRender
LinuxImpl*> (_ptrRenderer); | |
282 _ptrRenderer = NULL; | |
283 delete ptrRenderer; | |
284 } | |
285 break; | |
286 #else | |
287 //other platforms | |
288 #endif | |
289 | |
290 default: | |
291 // Error... | |
292 break; | |
293 } | |
294 } | |
295 } | |
296 | |
297 int64_t ModuleVideoRenderImpl::TimeUntilNextProcess() | |
298 { | |
299 // Not used | |
300 return 50; | |
301 } | |
302 void ModuleVideoRenderImpl::Process() {} | |
303 | |
304 void* | |
305 ModuleVideoRenderImpl::Window() | |
306 { | |
307 CriticalSectionScoped cs(&_moduleCrit); | |
308 return _ptrWindow; | |
309 } | |
310 | |
311 int32_t ModuleVideoRenderImpl::ChangeWindow(void* window) | |
312 { | |
313 | |
314 CriticalSectionScoped cs(&_moduleCrit); | |
315 | |
316 #if defined(WEBRTC_IOS) // WEBRTC_IOS must go before WEBRTC_MAC | |
317 _ptrRenderer = NULL; | |
318 delete _ptrRenderer; | |
319 | |
320 VideoRenderIosImpl* ptrRenderer; | |
321 ptrRenderer = new VideoRenderIosImpl(_id, window, _fullScreen); | |
322 if (!ptrRenderer) | |
323 { | |
324 return -1; | |
325 } | |
326 _ptrRenderer = reinterpret_cast<IVideoRender*>(ptrRenderer); | |
327 return _ptrRenderer->ChangeWindow(window); | |
328 #elif defined(WEBRTC_MAC) | |
329 | |
330 _ptrRenderer = NULL; | |
331 delete _ptrRenderer; | |
332 | |
333 #if defined(COCOA_RENDERING) | |
334 VideoRenderMacCocoaImpl* ptrRenderer; | |
335 ptrRenderer = new VideoRenderMacCocoaImpl(_id, kRenderCocoa, window, _fullSc
reen); | |
336 #elif defined(CARBON_RENDERING) | |
337 VideoRenderMacCarbonImpl* ptrRenderer; | |
338 ptrRenderer = new VideoRenderMacCarbonImpl(_id, kRenderCarbon, window, _full
Screen); | |
339 #endif | |
340 if (!ptrRenderer) | |
341 { | |
342 return -1; | |
343 } | |
344 _ptrRenderer = reinterpret_cast<IVideoRender*>(ptrRenderer); | |
345 return _ptrRenderer->ChangeWindow(window); | |
346 | |
347 #else | |
348 if (!_ptrRenderer) | |
349 { | |
350 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
351 "%s: No renderer", __FUNCTION__); | |
352 return -1; | |
353 } | |
354 return _ptrRenderer->ChangeWindow(window); | |
355 | |
356 #endif | |
357 } | |
358 | |
359 int32_t ModuleVideoRenderImpl::Id() | |
360 { | |
361 CriticalSectionScoped cs(&_moduleCrit); | |
362 return _id; | |
363 } | |
364 | |
365 uint32_t ModuleVideoRenderImpl::GetIncomingFrameRate(const uint32_t streamId) { | |
366 CriticalSectionScoped cs(&_moduleCrit); | |
367 | |
368 IncomingVideoStreamMap::iterator it = _streamRenderMap.find(streamId); | |
369 | |
370 if (it == _streamRenderMap.end()) { | |
371 // This stream doesn't exist | |
372 WEBRTC_TRACE(kTraceError, | |
373 kTraceVideoRenderer, | |
374 _id, | |
375 "%s: stream doesn't exist", | |
376 __FUNCTION__); | |
377 return 0; | |
378 } | |
379 assert(it->second != NULL); | |
380 return it->second->IncomingRate(); | |
381 } | |
382 | |
383 VideoRenderCallback* | |
384 ModuleVideoRenderImpl::AddIncomingRenderStream(const uint32_t streamId, | |
385 const uint32_t zOrder, | |
386 const float left, | |
387 const float top, | |
388 const float right, | |
389 const float bottom) | |
390 { | |
391 CriticalSectionScoped cs(&_moduleCrit); | |
392 | |
393 if (!_ptrRenderer) | |
394 { | |
395 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
396 "%s: No renderer", __FUNCTION__); | |
397 return NULL; | |
398 } | |
399 | |
400 if (_streamRenderMap.find(streamId) != _streamRenderMap.end()) { | |
401 // The stream already exists... | |
402 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
403 "%s: stream already exists", __FUNCTION__); | |
404 return NULL; | |
405 } | |
406 | |
407 VideoRenderCallback* ptrRenderCallback = | |
408 _ptrRenderer->AddIncomingRenderStream(streamId, zOrder, left, top, | |
409 right, bottom); | |
410 if (ptrRenderCallback == NULL) | |
411 { | |
412 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
413 "%s: Can't create incoming stream in renderer", | |
414 __FUNCTION__); | |
415 return NULL; | |
416 } | |
417 | |
418 // Create platform independant code | |
419 IncomingVideoStream* ptrIncomingStream = | |
420 new IncomingVideoStream(streamId, false); | |
421 ptrIncomingStream->SetRenderCallback(ptrRenderCallback); | |
422 VideoRenderCallback* moduleCallback = ptrIncomingStream->ModuleCallback(); | |
423 | |
424 // Store the stream | |
425 _streamRenderMap[streamId] = ptrIncomingStream; | |
426 | |
427 return moduleCallback; | |
428 } | |
429 | |
430 int32_t ModuleVideoRenderImpl::DeleteIncomingRenderStream( | |
431 const uint32_t s
treamId) | |
432 { | |
433 CriticalSectionScoped cs(&_moduleCrit); | |
434 | |
435 if (!_ptrRenderer) | |
436 { | |
437 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
438 "%s: No renderer", __FUNCTION__); | |
439 return -1; | |
440 } | |
441 | |
442 IncomingVideoStreamMap::iterator item = _streamRenderMap.find(streamId); | |
443 if (item == _streamRenderMap.end()) | |
444 { | |
445 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
446 "%s: stream doesn't exist", __FUNCTION__); | |
447 return -1; | |
448 } | |
449 | |
450 delete item->second; | |
451 | |
452 _ptrRenderer->DeleteIncomingRenderStream(streamId); | |
453 | |
454 _streamRenderMap.erase(item); | |
455 | |
456 return 0; | |
457 } | |
458 | |
459 int32_t ModuleVideoRenderImpl::AddExternalRenderCallback( | |
460 const uint32_t streamId, | |
461 VideoRenderCallback* renderObject) { | |
462 CriticalSectionScoped cs(&_moduleCrit); | |
463 | |
464 IncomingVideoStreamMap::iterator item = _streamRenderMap.find(streamId); | |
465 | |
466 if (item == _streamRenderMap.end()) | |
467 { | |
468 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
469 "%s: stream doesn't exist", __FUNCTION__); | |
470 return -1; | |
471 } | |
472 | |
473 if (item->second == NULL) { | |
474 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
475 "%s: could not get stream", __FUNCTION__); | |
476 return -1; | |
477 } | |
478 item->second->SetExternalCallback(renderObject); | |
479 return 0; | |
480 } | |
481 | |
482 int32_t ModuleVideoRenderImpl::GetIncomingRenderStreamProperties( | |
483 const uint32_t streamId, | |
484 uint32_t& zOrder, | |
485 float& left, | |
486 float& top, | |
487 float& right, | |
488 float& bottom) const { | |
489 CriticalSectionScoped cs(&_moduleCrit); | |
490 | |
491 if (!_ptrRenderer) | |
492 { | |
493 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
494 "%s: No renderer", __FUNCTION__); | |
495 return -1; | |
496 } | |
497 | |
498 return _ptrRenderer->GetIncomingRenderStreamProperties(streamId, zOrder, | |
499 left, top, right, | |
500 bottom); | |
501 } | |
502 | |
503 uint32_t ModuleVideoRenderImpl::GetNumIncomingRenderStreams() const | |
504 { | |
505 CriticalSectionScoped cs(&_moduleCrit); | |
506 | |
507 return static_cast<uint32_t>(_streamRenderMap.size()); | |
508 } | |
509 | |
510 bool ModuleVideoRenderImpl::HasIncomingRenderStream( | |
511 const uint32_t streamId) const { | |
512 CriticalSectionScoped cs(&_moduleCrit); | |
513 | |
514 return _streamRenderMap.find(streamId) != _streamRenderMap.end(); | |
515 } | |
516 | |
517 int32_t ModuleVideoRenderImpl::RegisterRawFrameCallback( | |
518 const uint32_t streamId, | |
519 VideoRenderCallback* callbackObj) { | |
520 return -1; | |
521 } | |
522 | |
523 int32_t ModuleVideoRenderImpl::StartRender(const uint32_t streamId) | |
524 { | |
525 CriticalSectionScoped cs(&_moduleCrit); | |
526 | |
527 if (!_ptrRenderer) | |
528 { | |
529 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
530 "%s: No renderer", __FUNCTION__); | |
531 return -1; | |
532 } | |
533 | |
534 // Start the stream | |
535 IncomingVideoStreamMap::iterator item = _streamRenderMap.find(streamId); | |
536 | |
537 if (item == _streamRenderMap.end()) | |
538 { | |
539 return -1; | |
540 } | |
541 | |
542 if (item->second->Start() == -1) | |
543 { | |
544 return -1; | |
545 } | |
546 | |
547 // Start the HW renderer | |
548 if (_ptrRenderer->StartRender() == -1) | |
549 { | |
550 return -1; | |
551 } | |
552 return 0; | |
553 } | |
554 | |
555 int32_t ModuleVideoRenderImpl::StopRender(const uint32_t streamId) | |
556 { | |
557 CriticalSectionScoped cs(&_moduleCrit); | |
558 | |
559 if (!_ptrRenderer) | |
560 { | |
561 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
562 "%s(%d): No renderer", __FUNCTION__, streamId); | |
563 return -1; | |
564 } | |
565 | |
566 // Stop the incoming stream | |
567 IncomingVideoStreamMap::iterator item = _streamRenderMap.find(streamId); | |
568 | |
569 if (item == _streamRenderMap.end()) | |
570 { | |
571 return -1; | |
572 } | |
573 | |
574 if (item->second->Stop() == -1) | |
575 { | |
576 return -1; | |
577 } | |
578 | |
579 return 0; | |
580 } | |
581 | |
582 int32_t ModuleVideoRenderImpl::ResetRender() | |
583 { | |
584 CriticalSectionScoped cs(&_moduleCrit); | |
585 | |
586 int32_t ret = 0; | |
587 // Loop through all incoming streams and reset them | |
588 for (IncomingVideoStreamMap::iterator it = _streamRenderMap.begin(); | |
589 it != _streamRenderMap.end(); | |
590 ++it) { | |
591 if (it->second->Reset() == -1) | |
592 ret = -1; | |
593 } | |
594 return ret; | |
595 } | |
596 | |
597 RawVideoType ModuleVideoRenderImpl::PreferredVideoType() const | |
598 { | |
599 CriticalSectionScoped cs(&_moduleCrit); | |
600 | |
601 if (_ptrRenderer == NULL) | |
602 { | |
603 return kVideoI420; | |
604 } | |
605 | |
606 return _ptrRenderer->PerferedVideoType(); | |
607 } | |
608 | |
609 bool ModuleVideoRenderImpl::IsFullScreen() | |
610 { | |
611 CriticalSectionScoped cs(&_moduleCrit); | |
612 | |
613 if (!_ptrRenderer) | |
614 { | |
615 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
616 "%s: No renderer", __FUNCTION__); | |
617 return false; | |
618 } | |
619 return _ptrRenderer->FullScreen(); | |
620 } | |
621 | |
622 int32_t ModuleVideoRenderImpl::GetScreenResolution( | |
623 uint32_t& screenWidth, | |
624 uint32_t& screenHeight)
const | |
625 { | |
626 CriticalSectionScoped cs(&_moduleCrit); | |
627 | |
628 if (!_ptrRenderer) | |
629 { | |
630 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
631 "%s: No renderer", __FUNCTION__); | |
632 return false; | |
633 } | |
634 return _ptrRenderer->GetScreenResolution(screenWidth, screenHeight); | |
635 } | |
636 | |
637 uint32_t ModuleVideoRenderImpl::RenderFrameRate( | |
638 const uint32_t streamId) | |
639 { | |
640 CriticalSectionScoped cs(&_moduleCrit); | |
641 | |
642 if (!_ptrRenderer) | |
643 { | |
644 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
645 "%s: No renderer", __FUNCTION__); | |
646 return false; | |
647 } | |
648 return _ptrRenderer->RenderFrameRate(streamId); | |
649 } | |
650 | |
651 int32_t ModuleVideoRenderImpl::SetStreamCropping( | |
652 const uint32_t streamId, | |
653 const float left, | |
654 const float top, | |
655 const float right, | |
656 const float bottom) | |
657 { | |
658 CriticalSectionScoped cs(&_moduleCrit); | |
659 | |
660 if (!_ptrRenderer) | |
661 { | |
662 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
663 "%s: No renderer", __FUNCTION__); | |
664 return false; | |
665 } | |
666 return _ptrRenderer->SetStreamCropping(streamId, left, top, right, bottom); | |
667 } | |
668 | |
669 int32_t ModuleVideoRenderImpl::SetTransparentBackground(const bool enable) | |
670 { | |
671 CriticalSectionScoped cs(&_moduleCrit); | |
672 | |
673 if (!_ptrRenderer) | |
674 { | |
675 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
676 "%s: No renderer", __FUNCTION__); | |
677 return false; | |
678 } | |
679 return _ptrRenderer->SetTransparentBackground(enable); | |
680 } | |
681 | |
682 int32_t ModuleVideoRenderImpl::FullScreenRender(void* window, const bool enable) | |
683 { | |
684 return -1; | |
685 } | |
686 | |
687 int32_t ModuleVideoRenderImpl::SetText( | |
688 const uint8_t textId, | |
689 const uint8_t* text, | |
690 const int32_t textLength, | |
691 const uint32_t textColorRef, | |
692 const uint32_t backgroundColorRef, | |
693 const float left, const float top, | |
694 const float right, | |
695 const float bottom) | |
696 { | |
697 CriticalSectionScoped cs(&_moduleCrit); | |
698 | |
699 if (!_ptrRenderer) | |
700 { | |
701 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
702 "%s: No renderer", __FUNCTION__); | |
703 return -1; | |
704 } | |
705 return _ptrRenderer->SetText(textId, text, textLength, textColorRef, | |
706 backgroundColorRef, left, top, right, bottom); | |
707 } | |
708 | |
709 int32_t ModuleVideoRenderImpl::SetBitmap(const void* bitMap, | |
710 const uint8_t pictureId, | |
711 const void* colorKey, | |
712 const float left, | |
713 const float top, | |
714 const float right, | |
715 const float bottom) | |
716 { | |
717 CriticalSectionScoped cs(&_moduleCrit); | |
718 | |
719 if (!_ptrRenderer) | |
720 { | |
721 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
722 "%s: No renderer", __FUNCTION__); | |
723 return -1; | |
724 } | |
725 return _ptrRenderer->SetBitmap(bitMap, pictureId, colorKey, left, top, | |
726 right, bottom); | |
727 } | |
728 | |
729 int32_t ModuleVideoRenderImpl::SetExpectedRenderDelay( | |
730 uint32_t stream_id, int32_t delay_ms) { | |
731 CriticalSectionScoped cs(&_moduleCrit); | |
732 | |
733 if (!_ptrRenderer) { | |
734 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
735 "%s: No renderer", __FUNCTION__); | |
736 return false; | |
737 } | |
738 | |
739 IncomingVideoStreamMap::const_iterator item = | |
740 _streamRenderMap.find(stream_id); | |
741 if (item == _streamRenderMap.end()) { | |
742 // This stream doesn't exist | |
743 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
744 "%s(%u, %d): stream doesn't exist", __FUNCTION__, stream_id, | |
745 delay_ms); | |
746 return -1; | |
747 } | |
748 | |
749 assert(item->second != NULL); | |
750 return item->second->SetExpectedRenderDelay(delay_ms); | |
751 } | |
752 | |
753 int32_t ModuleVideoRenderImpl::ConfigureRenderer( | |
754 const uint32_t streamId, | |
755 const unsigned int zOrder
, | |
756 const float left, | |
757 const float top, | |
758 const float right, | |
759 const float bottom) | |
760 { | |
761 CriticalSectionScoped cs(&_moduleCrit); | |
762 | |
763 if (!_ptrRenderer) | |
764 { | |
765 WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, | |
766 "%s: No renderer", __FUNCTION__); | |
767 return false; | |
768 } | |
769 return _ptrRenderer->ConfigureRenderer(streamId, zOrder, left, top, right, | |
770 bottom); | |
771 } | |
772 | |
773 } // namespace webrtc | |
OLD | NEW |