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
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_input_manager.h"
#include "vie_render_manager.h"
#include "video_engine/vie_renderer.h"
#endif
namespace webrtc

1
src/video_engine/vie_render_impl.cc
View File

@@ -29,6 +29,7 @@
#include "vie_channel_manager.h"
#include "vie_input_manager.h"
#include "vie_render_manager.h"
#include "video_engine/vie_renderer.h"
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.
*/
/*
* ViERenderManager.cpp
*/
#include "video_engine/vie_render_manager.h"
#include "vie_render_manager.h"
#include "engine_configurations.h"
#include "vie_defines.h"
#include "critical_section_wrapper.h"
#include "video_render.h"
#include "video_render_defines.h"
#include "rw_lock_wrapper.h"
#include "trace.h"
#include "modules/video_render/main/interface/video_render.h"
#include "modules/video_render/main/interface/video_render_defines.h"
#include "system_wrappers/interface/critical_section_wrapper.h"
#include "system_wrappers/interface/rw_lock_wrapper.h"
#include "system_wrappers/interface/trace.h"
#include "video_engine/vie_defines.h"
#include "video_engine/vie_renderer.h"
namespace webrtc {
// ----------------------------------------------------------------------------
// Constructor
// ----------------------------------------------------------------------------
ViERenderManagerScoped::ViERenderManagerScoped(const ViERenderManager& vieRenderManager)
:
ViEManagerScopedBase(vieRenderManager)
{
ViERenderManagerScoped::ViERenderManagerScoped(
const ViERenderManager& vie_render_manager)
: ViEManagerScopedBase(vie_render_manager) {
}
// ----------------------------------------------------------------------------
// Renderer()
//
// Returns a pointer to the ViERender object
// ----------------------------------------------------------------------------
ViERenderer* ViERenderManagerScoped::Renderer(WebRtc_Word32 renderId) const
{
return static_cast<const ViERenderManager*> (vie_manager_)->ViERenderPtr(
renderId);
ViERenderer* ViERenderManagerScoped::Renderer(WebRtc_Word32 render_id) const {
return static_cast<const ViERenderManager*>(vie_manager_)->ViERenderPtr(
render_id);
}
// ----------------------------------------------------------------------------
// Constructor
// ----------------------------------------------------------------------------
ViERenderManager::ViERenderManager(WebRtc_Word32 engineId) :
_listCritsect(*CriticalSectionWrapper::CreateCriticalSection()),
_engineId(engineId),
_streamToViERenderer(),
_renderList(),
_useExternalRenderModule(false)
{
WEBRTC_TRACE(webrtc::kTraceMemory, webrtc::kTraceVideo, ViEId(engineId),
"ViERenderManager::ViERenderManager(engineId: %d) - Constructor", engineId);
ViERenderManager::ViERenderManager(WebRtc_Word32 engine_id)
: list_critsect_(*CriticalSectionWrapper::CreateCriticalSection()),
engine_id_(engine_id),
use_external_render_module_(false) {
WEBRTC_TRACE(webrtc::kTraceMemory, webrtc::kTraceVideo, ViEId(engine_id),
"ViERenderManager::ViERenderManager(engine_id: %d) - "
"Constructor", engine_id);
}
// ----------------------------------------------------------------------------
// Destructor
// ----------------------------------------------------------------------------
ViERenderManager::~ViERenderManager() {
WEBRTC_TRACE(webrtc::kTraceMemory, webrtc::kTraceVideo, ViEId(engine_id_),
"ViERenderManager Destructor, engine_id: %d", engine_id_);
ViERenderManager::~ViERenderManager()
{
WEBRTC_TRACE(webrtc::kTraceMemory, webrtc::kTraceVideo, ViEId(_engineId),
"ViERenderManager Destructor, engineId: %d", _engineId);
while(_streamToViERenderer.Size()!=0)
{
MapItem* item=_streamToViERenderer.First();
assert(item);
const WebRtc_Word32 renderId=item->GetId();
item=NULL;// Deleted be RemoveRenderStream;
RemoveRenderStream(renderId);
}
delete &_listCritsect;
while (stream_to_vie_renderer_.Size() != 0) {
MapItem* item = stream_to_vie_renderer_.First();
assert(item);
const WebRtc_Word32 render_id = item->GetId();
// The renderer is delete in RemoveRenderStream.
item = NULL;
RemoveRenderStream(render_id);
}
delete &list_critsect_;
}
// ----------------------------------------------------------------------------
// RegisterVideoRenderModule
// ----------------------------------------------------------------------------
WebRtc_Word32 ViERenderManager::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)
{
// See if there is already a render module registered for the window that
// the registrant render module is associated with
VideoRender* ptrCurrentModule = FindRenderModule(renderModule.Window());
if (ptrCurrentModule)
{
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, ViEId(_engineId),
"A module is already registered for this window (window=%p, current module=%p, registrant module=%p",
renderModule.Window(), ptrCurrentModule, &renderModule);
return -1;
// Register module.
render_list_.PushBack(static_cast<void*>(&render_module));
use_external_render_module_ = true;
return 0;
}
WebRtc_Word32 ViERenderManager::DeRegisterVideoRenderModule(
VideoRender& render_module) {
// Check if there are streams in the module.
WebRtc_UWord32 n_streams = render_module.GetNumIncomingRenderStreams();
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
_renderList.PushBack(static_cast<void*>(&renderModule));
_useExternalRenderModule=true;
ViERenderer* ViERenderManager::AddRenderStream(const WebRtc_Word32 render_id,
void* window,
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;
}
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;
}
// ----------------------------------------------------------------------------
// DeRegisterVideoRenderModule
// ----------------------------------------------------------------------------
WebRtc_Word32 ViERenderManager::DeRegisterVideoRenderModule(VideoRender& renderModule)
{
// Check if there are streams in the module
WebRtc_UWord32 nStreams = renderModule.GetNumIncomingRenderStreams();
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;
VideoRender* ViERenderManager::FindRenderModule(void* window) {
VideoRender* renderer = NULL;
ListItem* list_item = NULL;
for (list_item = render_list_.First(); list_item != NULL;
list_item = render_list_.Next(list_item)) {
renderer = static_cast<VideoRender*>(list_item->GetItem());
if (renderer == NULL) {
break;
}
// Erase the render module from the map
ListItem* listItem = NULL;
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 (renderer->Window() == window) {
// We've found the render module.
break;
}
if (!found)
{
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, ViEId(_engineId), "Module not registered");
return -1;
}
return 0;
renderer = NULL;
}
return renderer;
}
// ----------------------------------------------------------------------------
// AddRenderStream
// ----------------------------------------------------------------------------
ViERenderer* ViERenderManager::ViERenderPtr(WebRtc_Word32 render_id) const {
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,
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;
return renderer;
}
// ----------------------------------------------------------------------------
// 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
} // 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.
*/
/*
* 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"
#ifndef WEBRTC_VIDEO_ENGINE_VIE_RENDER_MANAGER_H_
#define WEBRTC_VIDEO_ENGINE_VIE_RENDER_MANAGER_H_
#include "system_wrappers/interface/list_wrapper.h"
#include "system_wrappers/interface/map_wrapper.h"
#include "typedefs.h"
#include "list_wrapper.h"
#include "map_wrapper.h"
#include "vie_manager_base.h"
#include "vie_renderer.h"
#include "video_engine/vie_manager_base.h"
namespace webrtc {
@@ -33,54 +22,50 @@ class CriticalSectionWrapper;
class RWLockWrapper;
class VideoRender;
class VideoRenderCallback;
class ViERenderer;
class ViERenderManager: private ViEManagerBase
{
friend class ViERenderManagerScoped;
public:
ViERenderManager(WebRtc_Word32 engineId);
~ViERenderManager();
class ViERenderManager : private ViEManagerBase {
friend class ViERenderManagerScoped;
public:
explicit ViERenderManager(WebRtc_Word32 engine_id);
~ViERenderManager();
WebRtc_Word32 RegisterVideoRenderModule(VideoRender& renderModule);
WebRtc_Word32 DeRegisterVideoRenderModule(VideoRender& renderModule);
WebRtc_Word32 RegisterVideoRenderModule(VideoRender& render_module);
WebRtc_Word32 DeRegisterVideoRenderModule(VideoRender& render_module);
ViERenderer* AddRenderStream(const WebRtc_Word32 renderId,
void* window,
const WebRtc_UWord32 zOrder,
const float left,
const float top,
const float right,
const float bottom);
ViERenderer* AddRenderStream(const WebRtc_Word32 render_id,
void* window,
const WebRtc_UWord32 z_order,
const float left,
const float top,
const float right,
const float bottom);
WebRtc_Word32 RemoveRenderStream(WebRtc_Word32 renderId);
VideoRender* FindRenderModule(void* window);
WebRtc_Word32 RemoveRenderStream(WebRtc_Word32 render_id);
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
ViERenderer* ViERenderPtr(WebRtc_Word32 renderId) const;
// Methods used by ViERenderScoped.
ViERenderer* ViERenderPtr(WebRtc_Word32 render_id) const;
// Members
CriticalSectionWrapper& _listCritsect;
WebRtc_Word32 _engineId;
MapWrapper _streamToViERenderer; // Protected by ViEManagerBase
ListWrapper _renderList;
bool _useExternalRenderModule;
CriticalSectionWrapper& list_critsect_;
WebRtc_Word32 engine_id_;
MapWrapper stream_to_vie_renderer_; // Protected by ViEManagerBase.
ListWrapper render_list_;
bool use_external_render_module_;
};
class ViERenderManagerScoped: private ViEManagerScopedBase {
public:
explicit ViERenderManagerScoped(const ViERenderManager& vie_render_manager);
// ------------------------------------------------------------------
// ViERenderManagerScoped
// ------------------------------------------------------------------
class ViERenderManagerScoped: private ViEManagerScopedBase
{
public:
ViERenderManagerScoped(const ViERenderManager& vieRenderManager);
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_