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
{ {

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

93
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: explicit ViERenderManager(WebRtc_Word32 engine_id);
ViERenderManager(WebRtc_Word32 engineId); ~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 {
public:
explicit ViERenderManagerScoped(const ViERenderManager& vie_render_manager);
// ------------------------------------------------------------------ // Returns a pointer to the ViERender object.
// ViERenderManagerScoped ViERenderer* Renderer(WebRtc_Word32 render_id) const;
// ------------------------------------------------------------------
class ViERenderManagerScoped: private ViEManagerScopedBase
{
public:
ViERenderManagerScoped(const ViERenderManager& vieRenderManager);
ViERenderer* Renderer(WebRtc_Word32 renderId) const;
}; };
} //namespace webrtc } // namespace webrtc
#endif // WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_RENDER_MANAGER_H_ #endif // WEBRTC_VIDEO_ENGINE_VIE_RENDER_MANAGER_H_