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

Remove SetOverUseDetectorOptions and cleaned ViESharedData.

Browse Source 
R=pbos@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/1486004

git-svn-id: http://webrtc.googlecode.com/svn/trunk@4042 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
mflodman@webrtc.org 2013-05-16 11:13:18 +00:00
parent 7ebbea14a9
commit 4dee30927a
11 changed files with 22 additions and 262 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
webrtc/video_engine/include/vie_rtp_rtcp.h
View File

@ -295,16 +295,6 @@ class WEBRTC_DLLEXPORT ViERTP_RTCP {
const int video_channel,
unsigned int* estimated_bandwidth) const = 0;
// This function sets various options for the bandwidth estimator
// code. The options are applied to new channels only. For a given
// channel, the options that are active at the time when the channel
// is created are immutable for that channel. See
// http://tools.ietf.org/html/draft-alvestrand-rtcweb-congestion-02
// (or later, updated documentation) and common_types.h to get a
// feel for what the options do.
virtual int SetOverUseDetectorOptions(
const OverUseDetectorOptions& options) const = 0;
// This function enables capturing of RTP packets to a binary file on a
// specific channel and for a given direction. The file can later be
// replayed using e.g. RTP Tools rtpplay since the binary file format is

3
webrtc/video_engine/test/auto_test/source/vie_autotest_base.cc
View File

@ -130,10 +130,7 @@ void ViEAutoTest::ViEBaseAPITest() {
EXPECT_EQ(0, vie_base->GetVersion(version));
EXPECT_EQ(0, vie_base->LastError());
// Create without init
int video_channel = -1;
EXPECT_NE(0, vie_base->CreateChannel(video_channel)) <<
"Should fail since Init has not been called yet";
EXPECT_EQ(0, vie_base->Init());
EXPECT_EQ(0, vie_base->CreateChannel(video_channel));

57
webrtc/video_engine/vie_base_impl.cc
View File

@ -73,27 +73,12 @@ ViEBaseImpl::~ViEBaseImpl() {
int ViEBaseImpl::Init() {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, shared_data_.instance_id(),
"Init");
if (shared_data_.Initialized()) {
WEBRTC_TRACE(kTraceWarning, kTraceVideo, shared_data_.instance_id(),
"Init called twice");
return 0;
}
shared_data_.SetInitialized();
return 0;
}
int ViEBaseImpl::SetVoiceEngine(VoiceEngine* voice_engine) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(shared_data_.instance_id()),
"%s", __FUNCTION__);
if (!(shared_data_.Initialized())) {
shared_data_.SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_.instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_.instance_id());
return -1;
}
if (shared_data_.channel_manager()->SetVoiceEngine(voice_engine) != 0) {
shared_data_.SetLastError(kViEBaseVoEFailure);
return -1;
@ -104,15 +89,6 @@ int ViEBaseImpl::SetVoiceEngine(VoiceEngine* voice_engine) {
int ViEBaseImpl::CreateChannel(int& video_channel) { // NOLINT
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(shared_data_.instance_id()),
"%s", __FUNCTION__);
if (!(shared_data_.Initialized())) {
shared_data_.SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_.instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_.instance_id());
return -1;
}
if (shared_data_.channel_manager()->CreateChannel(&video_channel) == -1) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_.instance_id()),
"%s: Could not create channel", __FUNCTION__);
@ -138,15 +114,6 @@ int ViEBaseImpl::CreateReceiveChannel(int& video_channel, // NOLINT
int ViEBaseImpl::DeleteChannel(const int video_channel) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(shared_data_.instance_id()),
"%s(%d)", __FUNCTION__, video_channel);
if (!(shared_data_.Initialized())) {
shared_data_.SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_.instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_.instance_id());
return -1;
}
{
ViEChannelManagerScoped cs(*(shared_data_.channel_manager()));
ViEChannel* vie_channel = cs.Channel(video_channel);
@ -185,15 +152,6 @@ int ViEBaseImpl::ConnectAudioChannel(const int video_channel,
const int audio_channel) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(shared_data_.instance_id()),
"%s(%d)", __FUNCTION__, video_channel);
if (!(shared_data_.Initialized())) {
shared_data_.SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_.instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_.instance_id());
return -1;
}
ViEChannelManagerScoped cs(*(shared_data_.channel_manager()));
if (!cs.Channel(video_channel)) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_.instance_id()),
@ -213,13 +171,6 @@ int ViEBaseImpl::ConnectAudioChannel(const int video_channel,
int ViEBaseImpl::DisconnectAudioChannel(const int video_channel) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(shared_data_.instance_id()),
"%s(%d)", __FUNCTION__, video_channel);
if (!(shared_data_.Initialized())) {
shared_data_.SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_.instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_.instance_id());
return -1;
}
ViEChannelManagerScoped cs(*(shared_data_.channel_manager()));
if (!cs.Channel(video_channel)) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_.instance_id()),
@ -391,14 +342,6 @@ int ViEBaseImpl::LastError() {
int ViEBaseImpl::CreateChannel(int& video_channel, // NOLINT
int original_channel, bool sender) {
if (!(shared_data_.Initialized())) {
shared_data_.SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_.instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_.instance_id());
return -1;
}
ViEChannelManagerScoped cs(*(shared_data_.channel_manager()));
if (!cs.Channel(original_channel)) {
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_.instance_id()),

65
webrtc/video_engine/vie_capture_impl.cc
View File

@ -70,13 +70,6 @@ ViECaptureImpl::~ViECaptureImpl() {
int ViECaptureImpl::NumberOfCaptureDevices() {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s", __FUNCTION__);
if (!shared_data_->Initialized()) {
shared_data_->SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_->instance_id());
return -1;
}
return shared_data_->input_manager()->NumberOfCaptureDevices();
}
@ -88,13 +81,6 @@ int ViECaptureImpl::GetCaptureDevice(unsigned int list_number,
unsigned int unique_idUTF8Length) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s(list_number: %d)", __FUNCTION__, list_number);
if (!shared_data_->Initialized()) {
shared_data_->SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_->instance_id());
return -1;
}
return shared_data_->input_manager()->GetDeviceName(
list_number,
device_nameUTF8, device_nameUTF8Length,
@ -107,13 +93,6 @@ int ViECaptureImpl::AllocateCaptureDevice(
int& capture_id) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s(unique_idUTF8: %s)", __FUNCTION__, unique_idUTF8);
if (!shared_data_->Initialized()) {
shared_data_->SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_->instance_id());
return -1;
}
const int32_t result =
shared_data_->input_manager()->CreateCaptureDevice(
unique_idUTF8,
@ -130,14 +109,6 @@ int ViECaptureImpl::AllocateExternalCaptureDevice(
int& capture_id, ViEExternalCapture*& external_capture) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s", __FUNCTION__);
if (!shared_data_->Initialized()) {
shared_data_->SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_->instance_id());
return -1;
}
const int32_t result =
shared_data_->input_manager()->CreateExternalCaptureDevice(
external_capture, capture_id);
@ -153,17 +124,8 @@ int ViECaptureImpl::AllocateCaptureDevice(
VideoCaptureModule& capture_module, int& capture_id) { // NOLINT
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s", __FUNCTION__);
if (!shared_data_->Initialized()) {
shared_data_->SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_->instance_id());
return -1;
}
const int32_t result =
shared_data_->input_manager()->CreateCaptureDevice(&capture_module,
capture_id);
int32_t result = shared_data_->input_manager()->CreateCaptureDevice(
&capture_module, capture_id);
if (result != 0) {
shared_data_->SetLastError(result);
return -1;
@ -430,14 +392,6 @@ int ViECaptureImpl::NumberOfCapabilities(
shared_data_->instance_id());
return -1;
#endif
if (!shared_data_->Initialized()) {
shared_data_->SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_->instance_id());
return -1;
}
return shared_data_->input_manager()->NumberOfCaptureCapabilities(
unique_idUTF8);
}
@ -461,13 +415,6 @@ int ViECaptureImpl::GetCaptureCapability(const char* unique_idUTF8,
shared_data_->instance_id());
return -1;
#endif
if (!shared_data_->Initialized()) {
shared_data_->SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_->instance_id());
return -1;
}
if (shared_data_->input_manager()->GetCaptureCapability(
unique_idUTF8, capability_number, capability) != 0) {
shared_data_->SetLastError(kViECaptureDeviceUnknownError);
@ -507,14 +454,6 @@ int ViECaptureImpl::GetOrientation(const char* unique_idUTF8,
RotateCapturedFrame& orientation) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s (capture_device_name: %s)", __FUNCTION__, unique_idUTF8);
if (!shared_data_->Initialized()) {
shared_data_->SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_->instance_id());
return -1;
}
if (shared_data_->input_manager()->GetOrientation(
unique_idUTF8,
orientation) != 0) {

8
webrtc/video_engine/vie_image_process_impl.cc
View File

@ -72,14 +72,6 @@ int ViEImageProcessImpl::RegisterCaptureEffectFilter(
ViEEffectFilter& capture_filter) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s(capture_id: %d)", __FUNCTION__, capture_id);
if (!shared_data_->Initialized()) {
shared_data_->SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_->instance_id());
return -1;
}
ViEInputManagerScoped is(*(shared_data_->input_manager()));
ViECapturer* vie_capture = is.Capture(capture_id);
if (!vie_capture) {

29
webrtc/video_engine/vie_network_impl.cc
View File

@ -62,14 +62,6 @@ void ViENetworkImpl::SetNetworkTransmissionState(const int video_channel,
ViEId(shared_data_->instance_id(), video_channel),
"%s(event: Network %s)", __FUNCTION__,
is_transmitting ? "transmitting" : "not transmitting");
if (!shared_data_->Initialized()) {
shared_data_->SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_->instance_id());
return;
}
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
ViEEncoder* vie_encoder = cs.Encoder(video_channel);
if (!vie_encoder) {
@ -98,13 +90,6 @@ int ViENetworkImpl::RegisterSendTransport(const int video_channel,
WEBRTC_TRACE(kTraceApiCall, kTraceVideo,
ViEId(shared_data_->instance_id(), video_channel),
"%s(channel: %d)", __FUNCTION__, video_channel);
if (!shared_data_->Initialized()) {
shared_data_->SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_->instance_id());
return -1;
}
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
@ -161,13 +146,6 @@ int ViENetworkImpl::ReceivedRTPPacket(const int video_channel, const void* data,
ViEId(shared_data_->instance_id(), video_channel),
"%s(channel: %d, data: -, length: %d)", __FUNCTION__,
video_channel, length);
if (!shared_data_->Initialized()) {
shared_data_->SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_->instance_id());
return -1;
}
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {
@ -187,13 +165,6 @@ int ViENetworkImpl::ReceivedRTCPPacket(const int video_channel,
ViEId(shared_data_->instance_id(), video_channel),
"%s(channel: %d, data: -, length: %d)", __FUNCTION__,
video_channel, length);
if (!shared_data_->Initialized()) {
shared_data_->SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_->instance_id());
return -1;
}
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vie_channel) {

22
webrtc/video_engine/vie_render_impl.cc
View File

@ -104,13 +104,6 @@ int ViERenderImpl::AddRenderer(const int render_id, void* window,
"top: %f, right: %f, bottom: %f)",
__FUNCTION__, render_id, window, z_order, left, top, right,
bottom);
if (!shared_data_->Initialized()) {
shared_data_->SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_->instance_id());
return -1;
}
{
ViERenderManagerScoped rs(*(shared_data_->render_manager()));
if (rs.Renderer(render_id)) {
@ -163,14 +156,6 @@ int ViERenderImpl::AddRenderer(const int render_id, void* window,
int ViERenderImpl::RemoveRenderer(const int render_id) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s(render_id: %d)", __FUNCTION__, render_id);
if (!shared_data_->Initialized()) {
shared_data_->SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_->instance_id());
return -1;
}
ViERenderer* renderer = NULL;
{
ViERenderManagerScoped rs(*(shared_data_->render_manager()));
@ -348,13 +333,6 @@ int ViERenderImpl::AddRenderer(const int render_id,
shared_data_->SetLastError(kViERenderInvalidFrameFormat);
return -1;
}
if (!shared_data_->Initialized()) {
shared_data_->SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_->instance_id());
return -1;
}
{
// Verify the renderer doesn't exist.
ViERenderManagerScoped rs(*(shared_data_->render_manager()));

16
webrtc/video_engine/vie_rtp_rtcp_impl.cc
View File

@ -933,22 +933,6 @@ int ViERTP_RTCPImpl::GetEstimatedReceiveBandwidth(
return 0;
}
int ViERTP_RTCPImpl::SetOverUseDetectorOptions(
const OverUseDetectorOptions& options) const {
if (!shared_data_->Initialized()) {
shared_data_->SetLastError(kViENotInitialized);
WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(shared_data_->instance_id()),
"%s - ViE instance %d not initialized", __FUNCTION__,
shared_data_->instance_id());
return -1;
}
// Lock the channel manager to avoid creating a channel with
// "undefined" bwe settings (atomic copy).
ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
shared_data_->SetOverUseDetectorOptions(options);
return 0;
}
int ViERTP_RTCPImpl::StartRTPDump(const int video_channel,
const char file_nameUTF8[1024],
RTPDirections direction) {

2
webrtc/video_engine/vie_rtp_rtcp_impl.h
View File

@ -110,8 +110,6 @@ class ViERTP_RTCPImpl
virtual int GetEstimatedReceiveBandwidth(
const int video_channel,
unsigned int* estimated_bandwidth) const;
virtual int SetOverUseDetectorOptions(
const OverUseDetectorOptions& options) const;
virtual int StartRTPDump(const int video_channel,
const char file_nameUTF8[1024],
RTPDirections direction);

45
webrtc/video_engine/vie_shared_data.cc
View File

@ -19,50 +19,30 @@
namespace webrtc {
// Active instance counter
int ViESharedData::instance_counter_ = 0;
ViESharedData::ViESharedData(const Config& config)
: instance_id_(++instance_counter_),
initialized_(false),
number_cores_(CpuInfo::DetectNumberOfCores()),
over_use_detector_options_(),
channel_manager_(*new ViEChannelManager(instance_id_, number_cores_,
config)),
input_manager_(*new ViEInputManager(instance_id_, config)),
render_manager_(*new ViERenderManager(instance_id_)),
: number_cores_(CpuInfo::DetectNumberOfCores()),
channel_manager_(new ViEChannelManager(0, number_cores_, config)),
input_manager_(new ViEInputManager(0, config)),
render_manager_(new ViERenderManager(0)),
module_process_thread_(ProcessThread::CreateProcessThread()),
last_error_(0) {
Trace::CreateTrace();
channel_manager_.SetModuleProcessThread(module_process_thread_);
input_manager_.SetModuleProcessThread(module_process_thread_);
channel_manager_->SetModuleProcessThread(module_process_thread_);
input_manager_->SetModuleProcessThread(module_process_thread_);
module_process_thread_->Start();
}
ViESharedData::~ViESharedData() {
delete &input_manager_;
delete &channel_manager_;
delete &render_manager_;
// Release these ones before the process thread and the trace.
input_manager_.reset();
channel_manager_.reset();
render_manager_.reset();
module_process_thread_->Stop();
ProcessThread::DestroyProcessThread(module_process_thread_);
Trace::ReturnTrace();
}
bool ViESharedData::Initialized() const {
return initialized_;
}
int ViESharedData::SetInitialized() {
initialized_ = true;
return 0;
}
int ViESharedData::SetUnInitialized() {
initialized_ = false;
return 0;
}
void ViESharedData::SetLastError(const int error) const {
last_error_ = error;
}
@ -73,11 +53,6 @@ int ViESharedData::LastErrorInternal() const {
return error;
}
void ViESharedData::SetOverUseDetectorOptions(
const OverUseDetectorOptions& options) {
over_use_detector_options_ = options;
}
int ViESharedData::NumberOfCores() const {
return number_cores_;
}

27
webrtc/video_engine/vie_shared_data.h
View File

@ -14,7 +14,7 @@
#ifndef WEBRTC_VIDEO_ENGINE_VIE_SHARED_DATA_H_
#define WEBRTC_VIDEO_ENGINE_VIE_SHARED_DATA_H_
#include "video_engine/vie_defines.h"
#include "webrtc/system_wrappers/interface/scoped_ptr.h"
namespace webrtc {
@ -26,32 +26,25 @@ class ViERenderManager;
class ViESharedData {
public:
ViESharedData(const Config& config);
explicit ViESharedData(const Config& config);
~ViESharedData();
bool Initialized() const;
int SetInitialized();
int SetUnInitialized();
void SetLastError(const int error) const;
int LastErrorInternal() const;
void SetOverUseDetectorOptions(const OverUseDetectorOptions& options);
int NumberOfCores() const;
int instance_id() { return instance_id_;}
ViEChannelManager* channel_manager() { return &channel_manager_; }
ViEInputManager* input_manager() { return &input_manager_; }
ViERenderManager* render_manager() { return &render_manager_; }
// TODO(mflodman) Remove all calls to 'instance_id()'.
int instance_id() { return 0;}
ViEChannelManager* channel_manager() { return channel_manager_.get(); }
ViEInputManager* input_manager() { return input_manager_.get(); }
ViERenderManager* render_manager() { return render_manager_.get(); }
private:
static int instance_counter_;
const int instance_id_;
bool initialized_;
const int number_cores_;
OverUseDetectorOptions over_use_detector_options_;
ViEChannelManager& channel_manager_;
ViEInputManager& input_manager_;
ViERenderManager& render_manager_;
scoped_ptr<ViEChannelManager> channel_manager_;
scoped_ptr<ViEInputManager> input_manager_;
scoped_ptr<ViERenderManager> render_manager_;
ProcessThread* module_process_thread_;
mutable int last_error_;
};