generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactored ViERenderManager.

Browse Source 
Will follow up with a new CL for pointer/references and functino arguments.

Review URL: http://webrtc-codereview.appspot.com/323013

git-svn-id: http://webrtc.googlecode.com/svn/trunk@1191 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
mflodman@webrtc.org 2011-12-14 18:50:47 +00:00
parent 6601902504
commit 02afbeaca5
4 changed files with 234 additions and 312 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/video_engine/vie_file_impl.cc
View File

@ -34,6 +34,7 @@
#include "vie_impl.h" #include "vie_impl.h"
#include "vie_input_manager.h" #include "vie_input_manager.h"
#include "vie_render_manager.h" #include "vie_render_manager.h"
#include "video_engine/vie_renderer.h"
#endif #endif
namespace webrtc namespace webrtc

1
src/video_engine/vie_render_impl.cc
View File

@ -29,6 +29,7 @@
#include "vie_channel_manager.h" #include "vie_channel_manager.h"
#include "vie_input_manager.h" #include "vie_input_manager.h"
#include "vie_render_manager.h" #include "vie_render_manager.h"
#include "video_engine/vie_renderer.h"
namespace webrtc namespace webrtc
{ {

335
src/video_engine/vie_render_manager.cc
View File

@ -8,289 +8,224 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
/* #include "video_engine/vie_render_manager.h"
* ViERenderManager.cpp
*/
#include "vie_render_manager.h"
#include "engine_configurations.h" #include "engine_configurations.h"
#include "vie_defines.h" #include "modules/video_render/main/interface/video_render.h"
#include "modules/video_render/main/interface/video_render_defines.h"
#include "critical_section_wrapper.h" #include "system_wrappers/interface/critical_section_wrapper.h"
#include "video_render.h" #include "system_wrappers/interface/rw_lock_wrapper.h"
#include "video_render_defines.h" #include "system_wrappers/interface/trace.h"
#include "rw_lock_wrapper.h" #include "video_engine/vie_defines.h"
#include "trace.h" #include "video_engine/vie_renderer.h"
namespace webrtc { namespace webrtc {
// ---------------------------------------------------------------------------- ViERenderManagerScoped::ViERenderManagerScoped(
// Constructor const ViERenderManager& vie_render_manager)
// ---------------------------------------------------------------------------- : ViEManagerScopedBase(vie_render_manager) {
ViERenderManagerScoped::ViERenderManagerScoped(const ViERenderManager& vieRenderManager)
:
ViEManagerScopedBase(vieRenderManager)
{
} }
ViERenderer* ViERenderManagerScoped::Renderer(WebRtc_Word32 render_id) const {
// ----------------------------------------------------------------------------
// Renderer()
//
// Returns a pointer to the ViERender object
// ----------------------------------------------------------------------------
ViERenderer* ViERenderManagerScoped::Renderer(WebRtc_Word32 renderId) const
{
return static_cast<const ViERenderManager*>(vie_manager_)->ViERenderPtr( return static_cast<const ViERenderManager*>(vie_manager_)->ViERenderPtr(
renderId); render_id);
} }
ViERenderManager::ViERenderManager(WebRtc_Word32 engine_id)
// ---------------------------------------------------------------------------- : list_critsect_(*CriticalSectionWrapper::CreateCriticalSection()),
// Constructor engine_id_(engine_id),
// ---------------------------------------------------------------------------- use_external_render_module_(false) {
WEBRTC_TRACE(webrtc::kTraceMemory, webrtc::kTraceVideo, ViEId(engine_id),
ViERenderManager::ViERenderManager(WebRtc_Word32 engineId) : "ViERenderManager::ViERenderManager(engine_id: %d) - "
_listCritsect(*CriticalSectionWrapper::CreateCriticalSection()), "Constructor", engine_id);
_engineId(engineId),
_streamToViERenderer(),
_renderList(),
_useExternalRenderModule(false)
{
WEBRTC_TRACE(webrtc::kTraceMemory, webrtc::kTraceVideo, ViEId(engineId),
"ViERenderManager::ViERenderManager(engineId: %d) - Constructor", engineId);
} }
// ---------------------------------------------------------------------------- ViERenderManager::~ViERenderManager() {
// Destructor WEBRTC_TRACE(webrtc::kTraceMemory, webrtc::kTraceVideo, ViEId(engine_id_),
// ---------------------------------------------------------------------------- "ViERenderManager Destructor, engine_id: %d", engine_id_);
ViERenderManager::~ViERenderManager() while (stream_to_vie_renderer_.Size() != 0) {
{ MapItem* item = stream_to_vie_renderer_.First();
WEBRTC_TRACE(webrtc::kTraceMemory, webrtc::kTraceVideo, ViEId(_engineId),
"ViERenderManager Destructor, engineId: %d", _engineId);
while(_streamToViERenderer.Size()!=0)
{
MapItem* item=_streamToViERenderer.First();
assert(item); assert(item);
const WebRtc_Word32 renderId=item->GetId(); const WebRtc_Word32 render_id = item->GetId();
item=NULL;// Deleted be RemoveRenderStream; // The renderer is delete in RemoveRenderStream.
RemoveRenderStream(renderId); item = NULL;
RemoveRenderStream(render_id);
} }
delete &_listCritsect; delete &list_critsect_;
} }
// ---------------------------------------------------------------------------- WebRtc_Word32 ViERenderManager::RegisterVideoRenderModule(
// RegisterVideoRenderModule VideoRender& render_module) {
// ----------------------------------------------------------------------------
WebRtc_Word32 ViERenderManager::RegisterVideoRenderModule(VideoRender& renderModule)
{
// See if there is already a render module registered for the window that // See if there is already a render module registered for the window that
// the registrant render module is associated with // the registrant render module is associated with.
VideoRender* ptrCurrentModule = FindRenderModule(renderModule.Window()); VideoRender* current_module = FindRenderModule(render_module.Window());
if (ptrCurrentModule) if (current_module) {
{ WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, ViEId(engine_id_),
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, ViEId(_engineId), "A module is already registered for this window (window=%p, "
"A module is already registered for this window (window=%p, current module=%p, registrant module=%p", "current module=%p, registrant module=%p.",
renderModule.Window(), ptrCurrentModule, &renderModule); render_module.Window(), current_module, &render_module);
return -1; return -1;
} }
// Register module // Register module.
_renderList.PushBack(static_cast<void*>(&renderModule)); render_list_.PushBack(static_cast<void*>(&render_module));
_useExternalRenderModule=true; use_external_render_module_ = true;
return 0; return 0;
} }
// ---------------------------------------------------------------------------- WebRtc_Word32 ViERenderManager::DeRegisterVideoRenderModule(
// DeRegisterVideoRenderModule VideoRender& render_module) {
// ---------------------------------------------------------------------------- // Check if there are streams in the module.
WebRtc_UWord32 n_streams = render_module.GetNumIncomingRenderStreams();
WebRtc_Word32 ViERenderManager::DeRegisterVideoRenderModule(VideoRender& renderModule) if (n_streams != 0) {
{ WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, ViEId(engine_id_),
// Check if there are streams in the module "There are still %d streams in this module, cannot "
WebRtc_UWord32 nStreams = renderModule.GetNumIncomingRenderStreams(); "de-register", n_streams);
if (nStreams != 0)
{
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, ViEId(_engineId),
"There are still %d streams in this module, cannot de-register", nStreams);
return -1; return -1;
} }
// Erase the render module from the map // Erase the render module from the map.
ListItem* listItem = NULL; ListItem* list_item = NULL;
bool found = false; bool found = false;
for (listItem = _renderList.First(); listItem != NULL; listItem = _renderList.Next(listItem)) for (list_item = render_list_.First(); list_item != NULL;
{ list_item = render_list_.Next(list_item)) {
if (&renderModule == static_cast<VideoRender*>(listItem->GetItem())) if (&render_module == static_cast<VideoRender*>(list_item->GetItem())) {
{ // We've found our renderer.
// We've found our renderer render_list_.Erase(list_item);
_renderList.Erase(listItem);
found = true; found = true;
break; break;
} }
} }
if (!found) if (!found) {
{ WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, ViEId(engine_id_),
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, ViEId(_engineId), "Module not registered"); "Module not registered");
return -1; return -1;
} }
return 0; return 0;
} }
// ---------------------------------------------------------------------------- ViERenderer* ViERenderManager::AddRenderStream(const WebRtc_Word32 render_id,
// AddRenderStream
// ----------------------------------------------------------------------------
ViERenderer* ViERenderManager::AddRenderStream(const WebRtc_Word32 renderId,
void* window, void* window,
const WebRtc_UWord32 zOrder, const WebRtc_UWord32 z_order,
const float left, const float left,
const float top, const float top,
const float right, const float right,
const float bottom) const float bottom) {
{ CriticalSectionScoped cs(list_critsect_);
CriticalSectionScoped cs(_listCritsect);
if (_streamToViERenderer.Find(renderId) != NULL) if (stream_to_vie_renderer_.Find(render_id) != NULL) {
{
// This stream is already added to a renderer, not allowed! // This stream is already added to a renderer, not allowed!
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, ViEId(_engineId), "Render stream already exists"); WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, ViEId(engine_id_),
"Render stream already exists");
return NULL; return NULL;
} }
// Get the render module for this window // Get the render module for this window.
VideoRender* ptrRenderer = FindRenderModule(window); VideoRender* render_module = FindRenderModule(window);
if (ptrRenderer == NULL) if (render_module == NULL) {
{ // No render module for this window, create a new one.
// No render module for this window, create a new one render_module = VideoRender::CreateVideoRender(ViEModuleId(engine_id_, -1),
ptrRenderer = VideoRender::CreateVideoRender(ViEModuleId(_engineId, -1), window, false); window, false);
if (!ptrRenderer) if (!render_module) {
{ WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, ViEId(engine_id_),
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, ViEId(_engineId), "Could not create new render module"); "Could not create new render module");
return NULL; return NULL;
} }
_renderList.PushBack((void*) ptrRenderer); render_list_.PushBack(static_cast<void*>(render_module));
} }
ViERenderer* vieRenderer= ViERenderer::CreateViERenderer(renderId,_engineId,*ptrRenderer,*this,zOrder,left,top,right,bottom); ViERenderer* vie_renderer = ViERenderer::CreateViERenderer(render_id,
if(!vieRenderer) engine_id_,
{ *render_module,
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, ViEId(_engineId,renderId), "Could not create new render stream"); *this, z_order,
left, top, right,
bottom);
if (!vie_renderer) {
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo,
ViEId(engine_id_, render_id),
"Could not create new render stream");
return NULL; return NULL;
} }
stream_to_vie_renderer_.Insert(render_id, vie_renderer);
_streamToViERenderer.Insert(renderId, vieRenderer); return vie_renderer;
return vieRenderer;
} }
// ---------------------------------------------------------------------------- WebRtc_Word32 ViERenderManager::RemoveRenderStream(
// RemoveRenderStream const WebRtc_Word32 render_id) {
// ---------------------------------------------------------------------------- // We need exclusive right to the items in the render manager to delete a
// stream.
WebRtc_Word32 ViERenderManager::RemoveRenderStream(const WebRtc_Word32 renderId)
{
// We need exclusive right to the items in the rendermanager to delete a stream
ViEManagerWriteScoped(*this); ViEManagerWriteScoped(*this);
// Protect the list/map CriticalSectionScoped cs(list_critsect_);
CriticalSectionScoped cs(_listCritsect); MapItem* map_item = stream_to_vie_renderer_.Find(render_id);
if (!map_item) {
MapItem* mapItem = _streamToViERenderer.Find(renderId);
if (mapItem == NULL)
{
// No such stream // No such stream
WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideo, ViEId(_engineId), "No renderer for this stream found, channelId"); WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideo, ViEId(engine_id_),
"No renderer for this stream found, channel_id");
return 0; return 0;
} }
// Get the vieRender object. ViERenderer* vie_renderer = static_cast<ViERenderer*>(map_item->GetItem());
ViERenderer* ptrViERenderer = static_cast<ViERenderer*>(mapItem->GetItem()); assert(vie_renderer);
assert(ptrViERenderer);
// Get the render module pointer for this vieRender object // Get the render module pointer for this vie_render object.
VideoRender& renderer=ptrViERenderer->RenderModule(); VideoRender& renderer = vie_renderer->RenderModule();
// Delete the vieRender. // Delete the vie_render.
// This deletes the stream in the render module. // This deletes the stream in the render module.
delete ptrViERenderer; delete vie_renderer;
// Remove from the stream map // Remove from the stream map.
_streamToViERenderer.Erase(mapItem); stream_to_vie_renderer_.Erase(map_item);
// Check if there are other streams in the module // Check if there are other streams in the module.
if (!_useExternalRenderModule && renderer.GetNumIncomingRenderStreams() == 0) if (!use_external_render_module_ &&
{ renderer.GetNumIncomingRenderStreams() == 0) {
// Erase the render module from the map // Erase the render module from the map.
ListItem* listItem = NULL; ListItem* list_item = NULL;
for (listItem = _renderList.First(); listItem != NULL; listItem = _renderList.Next(listItem)) for (list_item = render_list_.First(); list_item != NULL;
{ list_item = render_list_.Next(list_item)) {
if (&renderer == static_cast<VideoRender*>(listItem->GetItem())) if (&renderer == static_cast<VideoRender*>(list_item->GetItem())) {
{ // We've found our renderer.
// We've found our renderer render_list_.Erase(list_item);
_renderList.Erase(listItem);
break; break;
} }
} }
// Destroy the module // Destroy the module.
VideoRender::DestroyVideoRender(&renderer); VideoRender::DestroyVideoRender(&renderer);
} }
return 0; return 0;
} }
// ---------------------------------------------------------------------------- VideoRender* ViERenderManager::FindRenderModule(void* window) {
// FindRenderModule VideoRender* renderer = NULL;
// ListItem* list_item = NULL;
// Returns a pointer to the render module if it exists in the render list. for (list_item = render_list_.First(); list_item != NULL;
// Assumed protected list_item = render_list_.Next(list_item)) {
// ---------------------------------------------------------------------------- renderer = static_cast<VideoRender*>(list_item->GetItem());
if (renderer == NULL) {
VideoRender* ViERenderManager::FindRenderModule(void* window)
{
VideoRender* ptrRenderer = NULL;
ListItem* listItem = NULL;
for (listItem = _renderList.First(); listItem != NULL; listItem = _renderList.Next(listItem))
{
ptrRenderer = static_cast<VideoRender*>(listItem->GetItem());
if (ptrRenderer == NULL)
{
break; break;
} }
if (ptrRenderer->Window() == window) if (renderer->Window() == window) {
{ // We've found the render module.
// We've found the render module
break; break;
} }
ptrRenderer = NULL; renderer = NULL;
} }
return ptrRenderer; return renderer;
} }
ViERenderer* ViERenderManager::ViERenderPtr(WebRtc_Word32 renderId) const ViERenderer* ViERenderManager::ViERenderPtr(WebRtc_Word32 render_id) const {
{ ViERenderer* renderer = NULL;
ViERenderer* ptrRenderer = NULL; MapItem* map_item = stream_to_vie_renderer_.Find(render_id);
if (!map_item) {
MapItem* mapItem = _streamToViERenderer.Find(renderId); // No such stream in any renderer.
if (mapItem == NULL)
{
// No such stream in any renderer
return NULL; return NULL;
} }
ptrRenderer = static_cast<ViERenderer*>(mapItem->GetItem()); renderer = static_cast<ViERenderer*>(map_item->GetItem());
return ptrRenderer; return renderer;
} }
} // namespace webrtc } // namespace webrtc

73
src/video_engine/vie_render_manager.h
View File

@ -8,24 +8,13 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
/* #ifndef WEBRTC_VIDEO_ENGINE_VIE_RENDER_MANAGER_H_
* vie_render_manager.h #define WEBRTC_VIDEO_ENGINE_VIE_RENDER_MANAGER_H_
*/
#ifndef WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_RENDER_MANAGER_H_
#define WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_RENDER_MANAGER_H_
// Defines
#include "engine_configurations.h"
#include "vie_defines.h"
#include "system_wrappers/interface/list_wrapper.h"
#include "system_wrappers/interface/map_wrapper.h"
#include "typedefs.h" #include "typedefs.h"
#include "list_wrapper.h" #include "video_engine/vie_manager_base.h"
#include "map_wrapper.h"
#include "vie_manager_base.h"
#include "vie_renderer.h"
namespace webrtc { namespace webrtc {
@ -33,54 +22,50 @@ class CriticalSectionWrapper;
class RWLockWrapper; class RWLockWrapper;
class VideoRender; class VideoRender;
class VideoRenderCallback; class VideoRenderCallback;
class ViERenderer;
class ViERenderManager: private ViEManagerBase class ViERenderManager : private ViEManagerBase {
{
friend class ViERenderManagerScoped; friend class ViERenderManagerScoped;
public: public:
ViERenderManager(WebRtc_Word32 engineId); explicit ViERenderManager(WebRtc_Word32 engine_id);
~ViERenderManager(); ~ViERenderManager();
WebRtc_Word32 RegisterVideoRenderModule(VideoRender& renderModule); WebRtc_Word32 RegisterVideoRenderModule(VideoRender& render_module);
WebRtc_Word32 DeRegisterVideoRenderModule(VideoRender& renderModule); WebRtc_Word32 DeRegisterVideoRenderModule(VideoRender& render_module);
ViERenderer* AddRenderStream(const WebRtc_Word32 renderId, ViERenderer* AddRenderStream(const WebRtc_Word32 render_id,
void* window, void* window,
const WebRtc_UWord32 zOrder, const WebRtc_UWord32 z_order,
const float left, const float left,
const float top, const float top,
const float right, const float right,
const float bottom); const float bottom);
WebRtc_Word32 RemoveRenderStream(WebRtc_Word32 renderId); WebRtc_Word32 RemoveRenderStream(WebRtc_Word32 render_id);
VideoRender* FindRenderModule(void* window);
private: private:
// Returns a pointer to the render module if it exists in the render list.
// Assumed protected.
VideoRender* FindRenderModule(void* window);
// Methods used by ViERenderScoped // Methods used by ViERenderScoped.
ViERenderer* ViERenderPtr(WebRtc_Word32 renderId) const; ViERenderer* ViERenderPtr(WebRtc_Word32 render_id) const;
// Members CriticalSectionWrapper& list_critsect_;
CriticalSectionWrapper& _listCritsect; WebRtc_Word32 engine_id_;
MapWrapper stream_to_vie_renderer_; // Protected by ViEManagerBase.
WebRtc_Word32 _engineId; ListWrapper render_list_;
MapWrapper _streamToViERenderer; // Protected by ViEManagerBase bool use_external_render_module_;
ListWrapper _renderList;
bool _useExternalRenderModule;
}; };
class ViERenderManagerScoped: private ViEManagerScopedBase {
// ------------------------------------------------------------------
// ViERenderManagerScoped
// ------------------------------------------------------------------
class ViERenderManagerScoped: private ViEManagerScopedBase
{
public: public:
ViERenderManagerScoped(const ViERenderManager& vieRenderManager); explicit ViERenderManagerScoped(const ViERenderManager& vie_render_manager);
ViERenderer* Renderer(WebRtc_Word32 renderId) const;
// Returns a pointer to the ViERender object.
ViERenderer* Renderer(WebRtc_Word32 render_id) const;
}; };
} // namespace webrtc } // namespace webrtc
#endif // WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_RENDER_MANAGER_H_ #endif // WEBRTC_VIDEO_ENGINE_VIE_RENDER_MANAGER_H_