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

Refactored vie_manager_base.*.

Browse Source 
The other files are only due to inheritance and will be refactored later. Same goes for pointer, references and function arguments.

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

git-svn-id: http://webrtc.googlecode.com/svn/trunk@1178 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
mflodman@webrtc.org 2011-12-14 08:18:42 +00:00
parent 6d609b59f3
commit 9a8fa4e65d
5 changed files with 101 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/video_engine/vie_channel_manager.cc
View File

@ -36,19 +36,19 @@ ViEChannelManagerScoped::ViEChannelManagerScoped(
ViEChannel* ViEChannelManagerScoped::Channel(int vieChannelId) const ViEChannel* ViEChannelManagerScoped::Channel(int vieChannelId) const
{ {
return static_cast<const ViEChannelManager*> return static_cast<const ViEChannelManager*>(vie_manager_)->ViEChannelPtr(
(_vieManager)->ViEChannelPtr(vieChannelId); vieChannelId);
} }
ViEEncoder* ViEChannelManagerScoped::Encoder(int vieChannelId) const ViEEncoder* ViEChannelManagerScoped::Encoder(int vieChannelId) const
{ {
return static_cast<const ViEChannelManager*> return static_cast<const ViEChannelManager*>(vie_manager_)->ViEEncoderPtr(
(_vieManager)->ViEEncoderPtr(vieChannelId); vieChannelId);
} }
bool ViEChannelManagerScoped::ChannelUsingViEEncoder(int channelId) const bool ViEChannelManagerScoped::ChannelUsingViEEncoder(int channelId) const
{ {
return (static_cast<const ViEChannelManager*> return (static_cast<const ViEChannelManager*>(vie_manager_))->
(_vieManager))->ChannelUsingViEEncoder( channelId); ChannelUsingViEEncoder(channelId);
} }
// ============================================================================ // ============================================================================

8
src/video_engine/vie_input_manager.cc
View File

@ -784,24 +784,24 @@ ViEInputManagerScoped::ViEInputManagerScoped(
ViECapturer* ViEInputManagerScoped::Capture(int captureId) const ViECapturer* ViEInputManagerScoped::Capture(int captureId) const
{ {
return static_cast<const ViEInputManager*> return static_cast<const ViEInputManager*>
(_vieManager)->ViECapturePtr(captureId); (vie_manager_)->ViECapturePtr(captureId);
} }
ViEFrameProviderBase* ViEInputManagerScoped::FrameProvider( ViEFrameProviderBase* ViEInputManagerScoped::FrameProvider(
const ViEFrameCallback* captureObserver) const const ViEFrameCallback* captureObserver) const
{ {
return static_cast<const ViEInputManager*> return static_cast<const ViEInputManager*>
(_vieManager)->ViEFrameProvider(captureObserver); (vie_manager_)->ViEFrameProvider(captureObserver);
} }
ViEFrameProviderBase* ViEInputManagerScoped::FrameProvider(int providerId) const ViEFrameProviderBase* ViEInputManagerScoped::FrameProvider(int providerId) const
{ {
return static_cast<const ViEInputManager*> return static_cast<const ViEInputManager*>
(_vieManager)->ViEFrameProvider( providerId); (vie_manager_)->ViEFrameProvider( providerId);
} }
ViEFilePlayer* ViEInputManagerScoped::FilePlayer(int fileId) const ViEFilePlayer* ViEInputManagerScoped::FilePlayer(int fileId) const
{ {
return static_cast<const ViEInputManager*> return static_cast<const ViEInputManager*>
(_vieManager)->ViEFilePlayerPtr(fileId); (vie_manager_)->ViEFilePlayerPtr(fileId);
} }
} // namespace webrtc } // namespace webrtc

113
src/video_engine/vie_manager_base.cc
View File

@ -8,106 +8,65 @@
* 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 "vie_manager_base.h"
#include "rw_lock_wrapper.h"
#include "assert.h" #include "assert.h"
#include "system_wrappers/interface/rw_lock_wrapper.h"
#include "video_engine/vie_manager_base.h"
namespace webrtc { namespace webrtc {
ViEManagerBase::ViEManagerBase() : ViEManagerBase::ViEManagerBase()
_instanceRWLock(*RWLockWrapper::CreateRWLock()) : instance_rwlock_(*RWLockWrapper::CreateRWLock()) {
{
}
ViEManagerBase::~ViEManagerBase()
{
delete &_instanceRWLock;
} }
// ---------------------------------------------------------------------------- ViEManagerBase::~ViEManagerBase() {
// ReadLockManager delete &instance_rwlock_;
//
// Lock count increase. Used by ViEManagerScopedBase
// ----------------------------------------------------------------------------
void ViEManagerBase::ReadLockManager() const
{
_instanceRWLock.AcquireLockShared();
} }
// ---------------------------------------------------------------------------- void ViEManagerBase::ReadLockManager() const {
// ReleaseLockManager instance_rwlock_.AcquireLockShared();
//
// Releases the lock count.
// ----------------------------------------------------------------------------
void ViEManagerBase::ReleaseLockManager() const
{
_instanceRWLock.ReleaseLockShared();
} }
// ---------------------------------------------------------------------------- void ViEManagerBase::ReleaseLockManager() const {
// WriteLockManager instance_rwlock_.ReleaseLockShared();
//
// Lock count increase. Used by ViEManagerWriteScoped
// ----------------------------------------------------------------------------
void ViEManagerBase::WriteLockManager()
{
_instanceRWLock.AcquireLockExclusive();
} }
// ---------------------------------------------------------------------------- void ViEManagerBase::WriteLockManager() {
// ReleaseLockManager instance_rwlock_.AcquireLockExclusive();
//
// Releases the lock count.
// ----------------------------------------------------------------------------
void ViEManagerBase::ReleaseWriteLockManager()
{
_instanceRWLock.ReleaseLockExclusive();
} }
// ---------------------------------------------------------------------------- void ViEManagerBase::ReleaseWriteLockManager() {
// ViEManagerScopedBase instance_rwlock_.ReleaseLockExclusive();
//
// ----------------------------------------------------------------------------
ViEManagerScopedBase::ViEManagerScopedBase(const ViEManagerBase& ViEManagerBase) :
_vieManager(&ViEManagerBase), _refCount(0)
{
_vieManager->ReadLockManager();
} }
ViEManagerScopedBase::~ViEManagerScopedBase() ViEManagerScopedBase::ViEManagerScopedBase(const ViEManagerBase& ViEManagerBase)
{ : vie_manager_(&ViEManagerBase),
assert(_refCount==0); ref_count_(0) {
_vieManager->ReleaseLockManager(); vie_manager_->ReadLockManager();
} }
// ---------------------------------------------------------------------------- ViEManagerScopedBase::~ViEManagerScopedBase() {
/// assert(ref_count_ == 0);
// ViEManagerWriteScoped vie_manager_->ReleaseLockManager();
//
// ----------------------------------------------------------------------------
ViEManagerWriteScoped::ViEManagerWriteScoped(ViEManagerBase& vieManager) :
_vieManager(&vieManager)
{
_vieManager->WriteLockManager();
} }
ViEManagerWriteScoped::~ViEManagerWriteScoped() ViEManagerWriteScoped::ViEManagerWriteScoped(ViEManagerBase& vie_manager)
{ : vie_manager_(&vie_manager) {
_vieManager->ReleaseWriteLockManager(); vie_manager_->WriteLockManager();
}
ViEManagerWriteScoped::~ViEManagerWriteScoped() {
vie_manager_->ReleaseWriteLockManager();
} }
// ----------------------------------------------------------------------------
// ViEManagedItemScopedBase
//
// ----------------------------------------------------------------------------
ViEManagedItemScopedBase::ViEManagedItemScopedBase( ViEManagedItemScopedBase::ViEManagedItemScopedBase(
ViEManagerScopedBase& vieScopedManager) : ViEManagerScopedBase& vie_scoped_manager)
_vieScopedManager(vieScopedManager) : vie_scoped_manager_(vie_scoped_manager) {
{ vie_scoped_manager_.ref_count_++;
_vieScopedManager._refCount++;
} }
ViEManagedItemScopedBase::~ViEManagedItemScopedBase() ViEManagedItemScopedBase::~ViEManagedItemScopedBase() {
{ vie_scoped_manager_.ref_count_--;
_vieScopedManager._refCount--;
} }
} // namespace webrtc
} // namespace webrtc

95
src/video_engine/vie_manager_base.h
View File

@ -8,56 +8,67 @@
* 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_MAIN_SOURCE_VIE_MANAGER_BASE_H_ #ifndef WEBRTC_VIDEO_ENGINE_VIE_MANAGER_BASE_H_
#define WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_MANAGER_BASE_H_ #define WEBRTC_VIDEO_ENGINE_VIE_MANAGER_BASE_H_
namespace webrtc { namespace webrtc {
class RWLockWrapper; class RWLockWrapper;
class ViEManagerBase class ViEManagerBase {
{ friend class ViEManagerScopedBase;
friend class ViEManagerScopedBase; friend class ViEManagedItemScopedBase;
friend class ViEManagedItemScopedBase; friend class ViEManagerWriteScoped;
friend class ViEManagerWriteScoped; public:
public: ViEManagerBase();
ViEManagerBase(void); ~ViEManagerBase();
~ViEManagerBase(void);
private: private:
void WriteLockManager(); // Exclusive lock, used by ViEManagerWriteScoped
void ReleaseWriteLockManager(); void WriteLockManager();
void ReadLockManager() const;
void ReleaseLockManager() const; // Releases exclusive lock, used by ViEManagerWriteScoped.
RWLockWrapper& _instanceRWLock; void ReleaseWriteLockManager();
// Increases lock count, used by ViEManagerScopedBase.
void ReadLockManager() const;
// Releases the lock count, used by ViEManagerScopedBase.
void ReleaseLockManager() const;
RWLockWrapper& instance_rwlock_;
}; };
class ViEManagerWriteScoped class ViEManagerWriteScoped {
{ public:
public: explicit ViEManagerWriteScoped(ViEManagerBase& vie_manager);
ViEManagerWriteScoped(ViEManagerBase& vieManager); ~ViEManagerWriteScoped();
~ViEManagerWriteScoped();
private: private:
ViEManagerBase* _vieManager; ViEManagerBase* vie_manager_;
}; };
class ViEManagerScopedBase class ViEManagerScopedBase {
{ friend class ViEManagedItemScopedBase;
friend class ViEManagedItemScopedBase; public:
public: explicit ViEManagerScopedBase(const ViEManagerBase& vie_manager);
ViEManagerScopedBase(const ViEManagerBase& vieManager); ~ViEManagerScopedBase();
~ViEManagerScopedBase();
protected: protected:
const ViEManagerBase* _vieManager; const ViEManagerBase* vie_manager_;
private:
int _refCount; private:
int ref_count_;
}; };
class ViEManagedItemScopedBase class ViEManagedItemScopedBase {
{ public:
public: explicit ViEManagedItemScopedBase(ViEManagerScopedBase& vie_scoped_manager);
ViEManagedItemScopedBase(ViEManagerScopedBase& vieScopedManager); ~ViEManagedItemScopedBase();
~ViEManagedItemScopedBase(); protected:
protected: ViEManagerScopedBase& vie_scoped_manager_;
ViEManagerScopedBase& _vieScopedManager;
}; };
} // namespace webrtc
#endif // WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_MANAGER_BASE_H_ } // namespace webrtc
#endif // WEBRTC_VIDEO_ENGINE_VIE_MANAGER_BASE_H_

4
src/video_engine/vie_render_manager.cc
View File

@ -46,7 +46,8 @@ ViERenderManagerScoped::ViERenderManagerScoped(const ViERenderManager& vieRender
ViERenderer* ViERenderManagerScoped::Renderer(WebRtc_Word32 renderId) const ViERenderer* ViERenderManagerScoped::Renderer(WebRtc_Word32 renderId) const
{ {
return static_cast<const ViERenderManager*> (_vieManager)->ViERenderPtr(renderId); return static_cast<const ViERenderManager*> (vie_manager_)->ViERenderPtr(
renderId);
} }
@ -293,4 +294,3 @@ ViERenderer* ViERenderManager::ViERenderPtr(WebRtc_Word32 renderId) const
} }
} //namespace webrtc } //namespace webrtc