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

Mark all virtual overrides in the hierarchy of Module as virtual and OVERRIDE.

Browse Source 
This will make a subsequent change I intend to do safer, where I'll change the
return type of one of the base Module functions, by breaking the compile if I
miss any overrides.

This also highlighted a number of unused functions (in many cases apparently
virtual "overrides" of no-longer-existent base functions).  I've removed some of
these.

This also highlighted several cases where "virtual" was used unnecessarily to
mark a function that was only defined in one class.  Removed "virtual" in those
cases.

BUG=none
TEST=none
R=andrew@webrtc.org, henrik.lundin@webrtc.org, mallinath@webrtc.org, mflodman@webrtc.org, stefan@webrtc.org, turaj@webrtc.org

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

git-svn-id: http://webrtc.googlecode.com/svn/trunk@7146 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
henrik.lundin@webrtc.org 2014-09-11 06:20:28 +00:00
parent 4c876453c8
commit 1972ff8a6e
25 changed files with 344 additions and 435 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
talk/app/webrtc/test/fakeaudiocapturemodule.cc
View File

@ -94,13 +94,6 @@ int FakeAudioCaptureModule::frames_received() const {
return frames_received_; return frames_received_;
} }
int32_t FakeAudioCaptureModule::Version(char* /*version*/,
uint32_t& /*remaining_buffer_in_bytes*/,
uint32_t& /*position*/) const {
ASSERT(false);
return 0;
}
int32_t FakeAudioCaptureModule::TimeUntilNextProcess() { int32_t FakeAudioCaptureModule::TimeUntilNextProcess() {
const uint32 current_time = rtc::Time(); const uint32 current_time = rtc::Time();
if (current_time < last_process_time_ms_) { if (current_time < last_process_time_ms_) {
@ -325,12 +318,6 @@ int32_t FakeAudioCaptureModule::WaveOutVolume(
return 0; return 0;
} }
int32_t FakeAudioCaptureModule::SpeakerIsAvailable(bool* available) {
// No speaker, just dropping audio. Return success.
*available = true;
return 0;
}
int32_t FakeAudioCaptureModule::InitSpeaker() { int32_t FakeAudioCaptureModule::InitSpeaker() {
// No speaker, just playing from file. Return success. // No speaker, just playing from file. Return success.
return 0; return 0;
@ -341,12 +328,6 @@ bool FakeAudioCaptureModule::SpeakerIsInitialized() const {
return 0; return 0;
} }
int32_t FakeAudioCaptureModule::MicrophoneIsAvailable(bool* available) {
// No microphone, just playing from file. Return success.
*available = true;
return 0;
}
int32_t FakeAudioCaptureModule::InitMicrophone() { int32_t FakeAudioCaptureModule::InitMicrophone() {
// No microphone, just playing from file. Return success. // No microphone, just playing from file. Return success.
return 0; return 0;

185
talk/app/webrtc/test/fakeaudiocapturemodule.h
View File

@ -76,133 +76,132 @@ class FakeAudioCaptureModule
// Only functions called by PeerConnection are implemented, the rest do // Only functions called by PeerConnection are implemented, the rest do
// nothing and return success. If a function is not expected to be called by // nothing and return success. If a function is not expected to be called by
// PeerConnection an assertion is triggered if it is in fact called. // PeerConnection an assertion is triggered if it is in fact called.
virtual int32_t Version(char* version, virtual int32_t TimeUntilNextProcess() OVERRIDE;
uint32_t& remaining_buffer_in_bytes, virtual int32_t Process() OVERRIDE;
uint32_t& position) const; virtual int32_t ChangeUniqueId(const int32_t id) OVERRIDE;
virtual int32_t TimeUntilNextProcess();
virtual int32_t Process();
virtual int32_t ChangeUniqueId(const int32_t id);
virtual int32_t ActiveAudioLayer(AudioLayer* audio_layer) const; virtual int32_t ActiveAudioLayer(AudioLayer* audio_layer) const OVERRIDE;
virtual ErrorCode LastError() const; virtual ErrorCode LastError() const OVERRIDE;
virtual int32_t RegisterEventObserver( virtual int32_t RegisterEventObserver(
webrtc::AudioDeviceObserver* event_callback); webrtc::AudioDeviceObserver* event_callback) OVERRIDE;
// Note: Calling this method from a callback may result in deadlock. // Note: Calling this method from a callback may result in deadlock.
virtual int32_t RegisterAudioCallback(webrtc::AudioTransport* audio_callback); virtual int32_t RegisterAudioCallback(
webrtc::AudioTransport* audio_callback) OVERRIDE;
virtual int32_t Init(); virtual int32_t Init() OVERRIDE;
virtual int32_t Terminate(); virtual int32_t Terminate() OVERRIDE;
virtual bool Initialized() const; virtual bool Initialized() const OVERRIDE;
virtual int16_t PlayoutDevices(); virtual int16_t PlayoutDevices() OVERRIDE;
virtual int16_t RecordingDevices(); virtual int16_t RecordingDevices() OVERRIDE;
virtual int32_t PlayoutDeviceName(uint16_t index, virtual int32_t PlayoutDeviceName(
char name[webrtc::kAdmMaxDeviceNameSize], uint16_t index,
char guid[webrtc::kAdmMaxGuidSize]); char name[webrtc::kAdmMaxDeviceNameSize],
virtual int32_t RecordingDeviceName(uint16_t index, char guid[webrtc::kAdmMaxGuidSize]) OVERRIDE;
char name[webrtc::kAdmMaxDeviceNameSize], virtual int32_t RecordingDeviceName(
char guid[webrtc::kAdmMaxGuidSize]); uint16_t index,
char name[webrtc::kAdmMaxDeviceNameSize],
char guid[webrtc::kAdmMaxGuidSize]) OVERRIDE;
virtual int32_t SetPlayoutDevice(uint16_t index); virtual int32_t SetPlayoutDevice(uint16_t index) OVERRIDE;
virtual int32_t SetPlayoutDevice(WindowsDeviceType device); virtual int32_t SetPlayoutDevice(WindowsDeviceType device) OVERRIDE;
virtual int32_t SetRecordingDevice(uint16_t index); virtual int32_t SetRecordingDevice(uint16_t index) OVERRIDE;
virtual int32_t SetRecordingDevice(WindowsDeviceType device); virtual int32_t SetRecordingDevice(WindowsDeviceType device) OVERRIDE;
virtual int32_t PlayoutIsAvailable(bool* available); virtual int32_t PlayoutIsAvailable(bool* available) OVERRIDE;
virtual int32_t InitPlayout(); virtual int32_t InitPlayout() OVERRIDE;
virtual bool PlayoutIsInitialized() const; virtual bool PlayoutIsInitialized() const OVERRIDE;
virtual int32_t RecordingIsAvailable(bool* available); virtual int32_t RecordingIsAvailable(bool* available) OVERRIDE;
virtual int32_t InitRecording(); virtual int32_t InitRecording() OVERRIDE;
virtual bool RecordingIsInitialized() const; virtual bool RecordingIsInitialized() const OVERRIDE;
virtual int32_t StartPlayout(); virtual int32_t StartPlayout() OVERRIDE;
virtual int32_t StopPlayout(); virtual int32_t StopPlayout() OVERRIDE;
virtual bool Playing() const; virtual bool Playing() const OVERRIDE;
virtual int32_t StartRecording(); virtual int32_t StartRecording() OVERRIDE;
virtual int32_t StopRecording(); virtual int32_t StopRecording() OVERRIDE;
virtual bool Recording() const; virtual bool Recording() const OVERRIDE;
virtual int32_t SetAGC(bool enable); virtual int32_t SetAGC(bool enable) OVERRIDE;
virtual bool AGC() const; virtual bool AGC() const OVERRIDE;
virtual int32_t SetWaveOutVolume(uint16_t volume_left, virtual int32_t SetWaveOutVolume(uint16_t volume_left,
uint16_t volume_right); uint16_t volume_right) OVERRIDE;
virtual int32_t WaveOutVolume(uint16_t* volume_left, virtual int32_t WaveOutVolume(uint16_t* volume_left,
uint16_t* volume_right) const; uint16_t* volume_right) const OVERRIDE;
virtual int32_t SpeakerIsAvailable(bool* available); virtual int32_t InitSpeaker() OVERRIDE;
virtual int32_t InitSpeaker(); virtual bool SpeakerIsInitialized() const OVERRIDE;
virtual bool SpeakerIsInitialized() const; virtual int32_t InitMicrophone() OVERRIDE;
virtual int32_t MicrophoneIsAvailable(bool* available); virtual bool MicrophoneIsInitialized() const OVERRIDE;
virtual int32_t InitMicrophone();
virtual bool MicrophoneIsInitialized() const;
virtual int32_t SpeakerVolumeIsAvailable(bool* available); virtual int32_t SpeakerVolumeIsAvailable(bool* available) OVERRIDE;
virtual int32_t SetSpeakerVolume(uint32_t volume); virtual int32_t SetSpeakerVolume(uint32_t volume) OVERRIDE;
virtual int32_t SpeakerVolume(uint32_t* volume) const; virtual int32_t SpeakerVolume(uint32_t* volume) const OVERRIDE;
virtual int32_t MaxSpeakerVolume(uint32_t* max_volume) const; virtual int32_t MaxSpeakerVolume(uint32_t* max_volume) const OVERRIDE;
virtual int32_t MinSpeakerVolume(uint32_t* min_volume) const; virtual int32_t MinSpeakerVolume(uint32_t* min_volume) const OVERRIDE;
virtual int32_t SpeakerVolumeStepSize(uint16_t* step_size) const; virtual int32_t SpeakerVolumeStepSize(uint16_t* step_size) const OVERRIDE;
virtual int32_t MicrophoneVolumeIsAvailable(bool* available); virtual int32_t MicrophoneVolumeIsAvailable(bool* available) OVERRIDE;
virtual int32_t SetMicrophoneVolume(uint32_t volume); virtual int32_t SetMicrophoneVolume(uint32_t volume) OVERRIDE;
virtual int32_t MicrophoneVolume(uint32_t* volume) const; virtual int32_t MicrophoneVolume(uint32_t* volume) const OVERRIDE;
virtual int32_t MaxMicrophoneVolume(uint32_t* max_volume) const; virtual int32_t MaxMicrophoneVolume(uint32_t* max_volume) const OVERRIDE;
virtual int32_t MinMicrophoneVolume(uint32_t* min_volume) const; virtual int32_t MinMicrophoneVolume(uint32_t* min_volume) const OVERRIDE;
virtual int32_t MicrophoneVolumeStepSize(uint16_t* step_size) const; virtual int32_t MicrophoneVolumeStepSize(uint16_t* step_size) const OVERRIDE;
virtual int32_t SpeakerMuteIsAvailable(bool* available); virtual int32_t SpeakerMuteIsAvailable(bool* available) OVERRIDE;
virtual int32_t SetSpeakerMute(bool enable); virtual int32_t SetSpeakerMute(bool enable) OVERRIDE;
virtual int32_t SpeakerMute(bool* enabled) const; virtual int32_t SpeakerMute(bool* enabled) const OVERRIDE;
virtual int32_t MicrophoneMuteIsAvailable(bool* available); virtual int32_t MicrophoneMuteIsAvailable(bool* available) OVERRIDE;
virtual int32_t SetMicrophoneMute(bool enable); virtual int32_t SetMicrophoneMute(bool enable) OVERRIDE;
virtual int32_t MicrophoneMute(bool* enabled) const; virtual int32_t MicrophoneMute(bool* enabled) const OVERRIDE;
virtual int32_t MicrophoneBoostIsAvailable(bool* available); virtual int32_t MicrophoneBoostIsAvailable(bool* available) OVERRIDE;
virtual int32_t SetMicrophoneBoost(bool enable); virtual int32_t SetMicrophoneBoost(bool enable) OVERRIDE;
virtual int32_t MicrophoneBoost(bool* enabled) const; virtual int32_t MicrophoneBoost(bool* enabled) const OVERRIDE;
virtual int32_t StereoPlayoutIsAvailable(bool* available) const; virtual int32_t StereoPlayoutIsAvailable(bool* available) const OVERRIDE;
virtual int32_t SetStereoPlayout(bool enable); virtual int32_t SetStereoPlayout(bool enable) OVERRIDE;
virtual int32_t StereoPlayout(bool* enabled) const; virtual int32_t StereoPlayout(bool* enabled) const OVERRIDE;
virtual int32_t StereoRecordingIsAvailable(bool* available) const; virtual int32_t StereoRecordingIsAvailable(bool* available) const OVERRIDE;
virtual int32_t SetStereoRecording(bool enable); virtual int32_t SetStereoRecording(bool enable) OVERRIDE;
virtual int32_t StereoRecording(bool* enabled) const; virtual int32_t StereoRecording(bool* enabled) const OVERRIDE;
virtual int32_t SetRecordingChannel(const ChannelType channel); virtual int32_t SetRecordingChannel(const ChannelType channel) OVERRIDE;
virtual int32_t RecordingChannel(ChannelType* channel) const; virtual int32_t RecordingChannel(ChannelType* channel) const OVERRIDE;
virtual int32_t SetPlayoutBuffer(const BufferType type, virtual int32_t SetPlayoutBuffer(const BufferType type,
uint16_t size_ms = 0); uint16_t size_ms = 0) OVERRIDE;
virtual int32_t PlayoutBuffer(BufferType* type, virtual int32_t PlayoutBuffer(BufferType* type,
uint16_t* size_ms) const; uint16_t* size_ms) const OVERRIDE;
virtual int32_t PlayoutDelay(uint16_t* delay_ms) const; virtual int32_t PlayoutDelay(uint16_t* delay_ms) const OVERRIDE;
virtual int32_t RecordingDelay(uint16_t* delay_ms) const; virtual int32_t RecordingDelay(uint16_t* delay_ms) const OVERRIDE;
virtual int32_t CPULoad(uint16_t* load) const; virtual int32_t CPULoad(uint16_t* load) const OVERRIDE;
virtual int32_t StartRawOutputFileRecording( virtual int32_t StartRawOutputFileRecording(
const char pcm_file_name_utf8[webrtc::kAdmMaxFileNameSize]); const char pcm_file_name_utf8[webrtc::kAdmMaxFileNameSize]) OVERRIDE;
virtual int32_t StopRawOutputFileRecording(); virtual int32_t StopRawOutputFileRecording() OVERRIDE;
virtual int32_t StartRawInputFileRecording( virtual int32_t StartRawInputFileRecording(
const char pcm_file_name_utf8[webrtc::kAdmMaxFileNameSize]); const char pcm_file_name_utf8[webrtc::kAdmMaxFileNameSize]) OVERRIDE;
virtual int32_t StopRawInputFileRecording(); virtual int32_t StopRawInputFileRecording() OVERRIDE;
virtual int32_t SetRecordingSampleRate(const uint32_t samples_per_sec); virtual int32_t SetRecordingSampleRate(
virtual int32_t RecordingSampleRate(uint32_t* samples_per_sec) const; const uint32_t samples_per_sec) OVERRIDE;
virtual int32_t SetPlayoutSampleRate(const uint32_t samples_per_sec); virtual int32_t RecordingSampleRate(uint32_t* samples_per_sec) const OVERRIDE;
virtual int32_t PlayoutSampleRate(uint32_t* samples_per_sec) const; virtual int32_t SetPlayoutSampleRate(const uint32_t samples_per_sec) OVERRIDE;
virtual int32_t PlayoutSampleRate(uint32_t* samples_per_sec) const OVERRIDE;
virtual int32_t ResetAudioDevice(); virtual int32_t ResetAudioDevice() OVERRIDE;
virtual int32_t SetLoudspeakerStatus(bool enable); virtual int32_t SetLoudspeakerStatus(bool enable) OVERRIDE;
virtual int32_t GetLoudspeakerStatus(bool* enabled) const; virtual int32_t GetLoudspeakerStatus(bool* enabled) const OVERRIDE;
// End of functions inherited from webrtc::AudioDeviceModule. // End of functions inherited from webrtc::AudioDeviceModule.
// The following function is inherited from rtc::MessageHandler. // The following function is inherited from rtc::MessageHandler.
virtual void OnMessage(rtc::Message* msg); virtual void OnMessage(rtc::Message* msg) OVERRIDE;
protected: protected:
// The constructor is protected because the class needs to be created as a // The constructor is protected because the class needs to be created as a

10
talk/app/webrtc/test/fakeaudiocapturemodule_unittest.cc
View File

@ -145,11 +145,6 @@ TEST_F(FakeAdmTest, TestProccess) {
TEST_F(FakeAdmTest, PlayoutTest) { TEST_F(FakeAdmTest, PlayoutTest) {
EXPECT_EQ(0, fake_audio_capture_module_->RegisterAudioCallback(this)); EXPECT_EQ(0, fake_audio_capture_module_->RegisterAudioCallback(this));
bool speaker_available = false;
EXPECT_EQ(0, fake_audio_capture_module_->SpeakerIsAvailable(
&speaker_available));
EXPECT_TRUE(speaker_available);
bool stereo_available = false; bool stereo_available = false;
EXPECT_EQ(0, EXPECT_EQ(0,
fake_audio_capture_module_->StereoPlayoutIsAvailable( fake_audio_capture_module_->StereoPlayoutIsAvailable(
@ -182,11 +177,6 @@ TEST_F(FakeAdmTest, PlayoutTest) {
TEST_F(FakeAdmTest, RecordTest) { TEST_F(FakeAdmTest, RecordTest) {
EXPECT_EQ(0, fake_audio_capture_module_->RegisterAudioCallback(this)); EXPECT_EQ(0, fake_audio_capture_module_->RegisterAudioCallback(this));
bool microphone_available = false;
EXPECT_EQ(0, fake_audio_capture_module_->MicrophoneIsAvailable(
&microphone_available));
EXPECT_TRUE(microphone_available);
bool stereo_available = false; bool stereo_available = false;
EXPECT_EQ(0, fake_audio_capture_module_->StereoRecordingIsAvailable( EXPECT_EQ(0, fake_audio_capture_module_->StereoRecordingIsAvailable(
&stereo_available)); &stereo_available));

46
talk/media/webrtc/fakewebrtcvideocapturemodule.h
View File

@ -44,76 +44,72 @@ class FakeWebRtcVideoCaptureModule : public webrtc::VideoCaptureModule {
running_(false), running_(false),
delay_(0) { delay_(0) {
} }
virtual int32_t Version(char* version, virtual int32_t TimeUntilNextProcess() OVERRIDE {
uint32_t& remaining_buffer_in_bytes,
uint32_t& position) const {
return 0; return 0;
} }
virtual int32_t TimeUntilNextProcess() { virtual int32_t Process() OVERRIDE {
return 0; return 0;
} }
virtual int32_t Process() { virtual int32_t ChangeUniqueId(const int32_t id) OVERRIDE {
return 0;
}
virtual int32_t ChangeUniqueId(const int32_t id) {
id_ = id; id_ = id;
return 0; return 0;
} }
virtual void RegisterCaptureDataCallback( virtual void RegisterCaptureDataCallback(
webrtc::VideoCaptureDataCallback& callback) { webrtc::VideoCaptureDataCallback& callback) OVERRIDE {
callback_ = &callback; callback_ = &callback;
} }
virtual void DeRegisterCaptureDataCallback() { callback_ = NULL; } virtual void DeRegisterCaptureDataCallback() OVERRIDE { callback_ = NULL; }
virtual void RegisterCaptureCallback(webrtc::VideoCaptureFeedBack& callback) { virtual void RegisterCaptureCallback(
webrtc::VideoCaptureFeedBack& callback) OVERRIDE {
// Not implemented. // Not implemented.
} }
virtual void DeRegisterCaptureCallback() { virtual void DeRegisterCaptureCallback() OVERRIDE {
// Not implemented. // Not implemented.
} }
virtual void SetCaptureDelay(int32_t delay) { delay_ = delay; } virtual void SetCaptureDelay(int32_t delay) OVERRIDE { delay_ = delay; }
virtual int32_t CaptureDelay() { return delay_; } virtual int32_t CaptureDelay() OVERRIDE { return delay_; }
virtual void EnableFrameRateCallback(const bool enable) { virtual void EnableFrameRateCallback(const bool enable) OVERRIDE {
// not implemented // not implemented
} }
virtual void EnableNoPictureAlarm(const bool enable) { virtual void EnableNoPictureAlarm(const bool enable) OVERRIDE {
// not implemented // not implemented
} }
virtual int32_t StartCapture( virtual int32_t StartCapture(
const webrtc::VideoCaptureCapability& cap) { const webrtc::VideoCaptureCapability& cap) OVERRIDE {
if (running_) return -1; if (running_) return -1;
cap_ = cap; cap_ = cap;
running_ = true; running_ = true;
return 0; return 0;
} }
virtual int32_t StopCapture() { virtual int32_t StopCapture() OVERRIDE {
running_ = false; running_ = false;
return 0; return 0;
} }
virtual const char* CurrentDeviceName() const { virtual const char* CurrentDeviceName() const OVERRIDE {
return NULL; // not implemented return NULL; // not implemented
} }
virtual bool CaptureStarted() { virtual bool CaptureStarted() OVERRIDE {
return running_; return running_;
} }
virtual int32_t CaptureSettings( virtual int32_t CaptureSettings(
webrtc::VideoCaptureCapability& settings) { webrtc::VideoCaptureCapability& settings) OVERRIDE {
if (!running_) return -1; if (!running_) return -1;
settings = cap_; settings = cap_;
return 0; return 0;
} }
virtual int32_t SetCaptureRotation( virtual int32_t SetCaptureRotation(
webrtc::VideoCaptureRotation rotation) { webrtc::VideoCaptureRotation rotation) OVERRIDE {
return -1; // not implemented return -1; // not implemented
} }
virtual VideoCaptureEncodeInterface* GetEncodeInterface( virtual VideoCaptureEncodeInterface* GetEncodeInterface(
const webrtc::VideoCodec& codec) { const webrtc::VideoCodec& codec) OVERRIDE {
return NULL; // not implemented return NULL; // not implemented
} }
virtual int32_t AddRef() { virtual int32_t AddRef() OVERRIDE {
return 0; return 0;
} }
virtual int32_t Release() { virtual int32_t Release() OVERRIDE {
delete this; delete this;
return 0; return 0;
} }

73
talk/media/webrtc/webrtcpassthroughrender.h
View File

@ -41,26 +41,20 @@ class WebRtcPassthroughRender : public webrtc::VideoRender {
WebRtcPassthroughRender(); WebRtcPassthroughRender();
virtual ~WebRtcPassthroughRender(); virtual ~WebRtcPassthroughRender();
virtual int32_t Version(int8_t* version, virtual int32_t ChangeUniqueId(const int32_t id) OVERRIDE {
uint32_t& remainingBufferInBytes,
uint32_t& position) const {
return 0; return 0;
} }
virtual int32_t ChangeUniqueId(const int32_t id) { virtual int32_t TimeUntilNextProcess() OVERRIDE { return 0; }
return 0;
}
virtual int32_t TimeUntilNextProcess() { return 0; } virtual int32_t Process() OVERRIDE { return 0; }
virtual int32_t Process() { return 0; } virtual void* Window() OVERRIDE {
virtual void* Window() {
rtc::CritScope cs(&render_critical_); rtc::CritScope cs(&render_critical_);
return window_; return window_;
} }
virtual int32_t ChangeWindow(void* window) { virtual int32_t ChangeWindow(void* window) OVERRIDE {
rtc::CritScope cs(&render_critical_); rtc::CritScope cs(&render_critical_);
window_ = window; window_ = window;
return 0; return 0;
@ -70,64 +64,60 @@ class WebRtcPassthroughRender : public webrtc::VideoRender {
const uint32_t stream_id, const uint32_t stream_id,
const uint32_t zOrder, const uint32_t zOrder,
const float left, const float top, const float left, const float top,
const float right, const float bottom); const float right, const float bottom) OVERRIDE;
virtual int32_t DeleteIncomingRenderStream(const uint32_t stream_id); virtual int32_t DeleteIncomingRenderStream(const uint32_t stream_id) OVERRIDE;
virtual int32_t AddExternalRenderCallback( virtual int32_t AddExternalRenderCallback(
const uint32_t stream_id, const uint32_t stream_id,
webrtc::VideoRenderCallback* render_object); webrtc::VideoRenderCallback* render_object) OVERRIDE;
virtual int32_t GetIncomingRenderStreamProperties( virtual int32_t GetIncomingRenderStreamProperties(
const uint32_t stream_id, const uint32_t stream_id,
uint32_t& zOrder, uint32_t& zOrder,
float& left, float& top, float& left, float& top,
float& right, float& bottom) const { float& right, float& bottom) const OVERRIDE {
return -1; return -1;
} }
virtual uint32_t GetIncomingFrameRate( virtual uint32_t GetIncomingFrameRate(const uint32_t stream_id) OVERRIDE {
const uint32_t stream_id) {
return 0; return 0;
} }
virtual uint32_t GetNumIncomingRenderStreams() const { virtual uint32_t GetNumIncomingRenderStreams() const OVERRIDE {
return static_cast<uint32_t>(stream_render_map_.size()); return static_cast<uint32_t>(stream_render_map_.size());
} }
virtual bool HasIncomingRenderStream(const uint32_t stream_id) const; virtual bool HasIncomingRenderStream(const uint32_t stream_id) const OVERRIDE;
virtual int32_t RegisterRawFrameCallback( virtual int32_t RegisterRawFrameCallback(
const uint32_t stream_id, const uint32_t stream_id,
webrtc::VideoRenderCallback* callback_obj) { webrtc::VideoRenderCallback* callback_obj) OVERRIDE {
return -1; return -1;
} }
virtual int32_t GetLastRenderedFrame( virtual int32_t GetLastRenderedFrame(
const uint32_t stream_id, const uint32_t stream_id,
webrtc::I420VideoFrame &frame) const { webrtc::I420VideoFrame &frame) const OVERRIDE {
return -1; return -1;
} }
virtual int32_t StartRender( virtual int32_t StartRender(const uint32_t stream_id) OVERRIDE;
const uint32_t stream_id);
virtual int32_t StopRender( virtual int32_t StopRender(const uint32_t stream_id) OVERRIDE;
const uint32_t stream_id);
virtual int32_t ResetRender() { return 0; } virtual int32_t ResetRender() OVERRIDE { return 0; }
virtual webrtc::RawVideoType PreferredVideoType() const; virtual webrtc::RawVideoType PreferredVideoType() const OVERRIDE;
virtual bool IsFullScreen() { return false; } virtual bool IsFullScreen() OVERRIDE { return false; }
virtual int32_t GetScreenResolution(uint32_t& screenWidth, virtual int32_t GetScreenResolution(uint32_t& screenWidth,
uint32_t& screenHeight) const { uint32_t& screenHeight) const OVERRIDE {
return -1; return -1;
} }
virtual uint32_t RenderFrameRate( virtual uint32_t RenderFrameRate(const uint32_t stream_id) OVERRIDE {
const uint32_t stream_id) {
return 0; return 0;
} }
@ -135,11 +125,12 @@ class WebRtcPassthroughRender : public webrtc::VideoRender {
const uint32_t stream_id, const uint32_t stream_id,
const float left, const float top, const float left, const float top,
const float right, const float right,
const float bottom) { const float bottom) OVERRIDE {
return -1; return -1;
} }
virtual int32_t SetExpectedRenderDelay(uint32_t stream_id, int32_t delay_ms) { virtual int32_t SetExpectedRenderDelay(uint32_t stream_id,
int32_t delay_ms) OVERRIDE {
return -1; return -1;
} }
@ -148,22 +139,22 @@ class WebRtcPassthroughRender : public webrtc::VideoRender {
const unsigned int zOrder, const unsigned int zOrder,
const float left, const float top, const float left, const float top,
const float right, const float right,
const float bottom) { const float bottom) OVERRIDE {
return -1; return -1;
} }
virtual int32_t SetTransparentBackground(const bool enable) { virtual int32_t SetTransparentBackground(const bool enable) OVERRIDE {
return -1; return -1;
} }
virtual int32_t FullScreenRender(void* window, const bool enable) { virtual int32_t FullScreenRender(void* window, const bool enable) OVERRIDE {
return -1; return -1;
} }
virtual int32_t SetBitmap(const void* bitMap, virtual int32_t SetBitmap(const void* bitMap,
const uint8_t pictureId, const void* colorKey, const uint8_t pictureId, const void* colorKey,
const float left, const float top, const float left, const float top,
const float right, const float bottom) { const float right, const float bottom) OVERRIDE {
return -1; return -1;
} }
@ -173,27 +164,27 @@ class WebRtcPassthroughRender : public webrtc::VideoRender {
const uint32_t textColorRef, const uint32_t textColorRef,
const uint32_t backgroundColorRef, const uint32_t backgroundColorRef,
const float left, const float top, const float left, const float top,
const float right, const float bottom) { const float right, const float bottom) OVERRIDE {
return -1; return -1;
} }
virtual int32_t SetStartImage( virtual int32_t SetStartImage(
const uint32_t stream_id, const uint32_t stream_id,
const webrtc::I420VideoFrame& videoFrame) { const webrtc::I420VideoFrame& videoFrame) OVERRIDE {
return -1; return -1;
} }
virtual int32_t SetTimeoutImage( virtual int32_t SetTimeoutImage(
const uint32_t stream_id, const uint32_t stream_id,
const webrtc::I420VideoFrame& videoFrame, const webrtc::I420VideoFrame& videoFrame,
const uint32_t timeout) { const uint32_t timeout) OVERRIDE {
return -1; return -1;
} }
virtual int32_t MirrorRenderStream(const int renderId, virtual int32_t MirrorRenderStream(const int renderId,
const bool enable, const bool enable,
const bool mirrorXAxis, const bool mirrorXAxis,
const bool mirrorYAxis) { const bool mirrorYAxis) OVERRIDE {
return -1; return -1;
} }

133
webrtc/modules/audio_coding/main/acm2/audio_coding_module_impl.h
View File

@ -36,83 +36,84 @@ class AudioCodingModuleImpl : public AudioCodingModule {
~AudioCodingModuleImpl(); ~AudioCodingModuleImpl();
// Change the unique identifier of this object. // Change the unique identifier of this object.
virtual int32_t ChangeUniqueId(const int32_t id); virtual int32_t ChangeUniqueId(const int32_t id) OVERRIDE;
// Returns the number of milliseconds until the module want a worker thread // Returns the number of milliseconds until the module want a worker thread
// to call Process. // to call Process.
int32_t TimeUntilNextProcess(); virtual int32_t TimeUntilNextProcess() OVERRIDE;
// Process any pending tasks such as timeouts. // Process any pending tasks such as timeouts.
int32_t Process(); virtual int32_t Process() OVERRIDE;
///////////////////////////////////////// /////////////////////////////////////////
// Sender // Sender
// //
// Initialize send codec. // Initialize send codec.
int InitializeSender(); virtual int InitializeSender() OVERRIDE;
// Reset send codec. // Reset send codec.
int ResetEncoder(); virtual int ResetEncoder() OVERRIDE;
// Can be called multiple times for Codec, CNG, RED. // Can be called multiple times for Codec, CNG, RED.
int RegisterSendCodec(const CodecInst& send_codec); virtual int RegisterSendCodec(const CodecInst& send_codec) OVERRIDE;
// Register Secondary codec for dual-streaming. Dual-streaming is activated // Register Secondary codec for dual-streaming. Dual-streaming is activated
// right after the secondary codec is registered. // right after the secondary codec is registered.
int RegisterSecondarySendCodec(const CodecInst& send_codec); virtual int RegisterSecondarySendCodec(const CodecInst& send_codec) OVERRIDE;
// Unregister the secondary codec. Dual-streaming is deactivated right after // Unregister the secondary codec. Dual-streaming is deactivated right after
// deregistering secondary codec. // deregistering secondary codec.
void UnregisterSecondarySendCodec(); virtual void UnregisterSecondarySendCodec() OVERRIDE;
// Get the secondary codec. // Get the secondary codec.
int SecondarySendCodec(CodecInst* secondary_codec) const; virtual int SecondarySendCodec(CodecInst* secondary_codec) const OVERRIDE;
// Get current send codec. // Get current send codec.
int SendCodec(CodecInst* current_codec) const; virtual int SendCodec(CodecInst* current_codec) const OVERRIDE;
// Get current send frequency. // Get current send frequency.
int SendFrequency() const; virtual int SendFrequency() const OVERRIDE;
// Get encode bit-rate. // Get encode bit-rate.
// Adaptive rate codecs return their current encode target rate, while other // Adaptive rate codecs return their current encode target rate, while other
// codecs return there long-term average or their fixed rate. // codecs return there long-term average or their fixed rate.
int SendBitrate() const; virtual int SendBitrate() const OVERRIDE;
// Set available bandwidth, inform the encoder about the // Set available bandwidth, inform the encoder about the
// estimated bandwidth received from the remote party. // estimated bandwidth received from the remote party.
virtual int SetReceivedEstimatedBandwidth(int bw); virtual int SetReceivedEstimatedBandwidth(int bw) OVERRIDE;
// Register a transport callback which will be // Register a transport callback which will be
// called to deliver the encoded buffers. // called to deliver the encoded buffers.
int RegisterTransportCallback(AudioPacketizationCallback* transport); virtual int RegisterTransportCallback(
AudioPacketizationCallback* transport) OVERRIDE;
// Add 10 ms of raw (PCM) audio data to the encoder. // Add 10 ms of raw (PCM) audio data to the encoder.
int Add10MsData(const AudioFrame& audio_frame); virtual int Add10MsData(const AudioFrame& audio_frame) OVERRIDE;
///////////////////////////////////////// /////////////////////////////////////////
// (RED) Redundant Coding // (RED) Redundant Coding
// //
// Configure RED status i.e. on/off. // Configure RED status i.e. on/off.
int SetREDStatus(bool enable_red); virtual int SetREDStatus(bool enable_red) OVERRIDE;
// Get RED status. // Get RED status.
bool REDStatus() const; virtual bool REDStatus() const OVERRIDE;
///////////////////////////////////////// /////////////////////////////////////////
// (FEC) Forward Error Correction (codec internal) // (FEC) Forward Error Correction (codec internal)
// //
// Configure FEC status i.e. on/off. // Configure FEC status i.e. on/off.
int SetCodecFEC(bool enabled_codec_fec); virtual int SetCodecFEC(bool enabled_codec_fec) OVERRIDE;
// Get FEC status. // Get FEC status.
bool CodecFEC() const; virtual bool CodecFEC() const OVERRIDE;
// Set target packet loss rate // Set target packet loss rate
int SetPacketLossRate(int loss_rate); virtual int SetPacketLossRate(int loss_rate) OVERRIDE;
///////////////////////////////////////// /////////////////////////////////////////
// (VAD) Voice Activity Detection // (VAD) Voice Activity Detection
@ -120,95 +121,98 @@ class AudioCodingModuleImpl : public AudioCodingModule {
// (CNG) Comfort Noise Generation // (CNG) Comfort Noise Generation
// //
int SetVAD(bool enable_dtx = true, virtual int SetVAD(bool enable_dtx = true,
bool enable_vad = false, bool enable_vad = false,
ACMVADMode mode = VADNormal); ACMVADMode mode = VADNormal) OVERRIDE;
int VAD(bool* dtx_enabled, bool* vad_enabled, ACMVADMode* mode) const; virtual int VAD(bool* dtx_enabled,
bool* vad_enabled,
ACMVADMode* mode) const OVERRIDE;
int RegisterVADCallback(ACMVADCallback* vad_callback); virtual int RegisterVADCallback(ACMVADCallback* vad_callback) OVERRIDE;
///////////////////////////////////////// /////////////////////////////////////////
// Receiver // Receiver
// //
// Initialize receiver, resets codec database etc. // Initialize receiver, resets codec database etc.
int InitializeReceiver(); virtual int InitializeReceiver() OVERRIDE;
// Reset the decoder state. // Reset the decoder state.
int ResetDecoder(); virtual int ResetDecoder() OVERRIDE;
// Get current receive frequency. // Get current receive frequency.
int ReceiveFrequency() const; virtual int ReceiveFrequency() const OVERRIDE;
// Get current playout frequency. // Get current playout frequency.
int PlayoutFrequency() const; virtual int PlayoutFrequency() const OVERRIDE;
// Register possible receive codecs, can be called multiple times, // Register possible receive codecs, can be called multiple times,
// for codecs, CNG, DTMF, RED. // for codecs, CNG, DTMF, RED.
int RegisterReceiveCodec(const CodecInst& receive_codec); virtual int RegisterReceiveCodec(const CodecInst& receive_codec) OVERRIDE;
// Get current received codec. // Get current received codec.
int ReceiveCodec(CodecInst* current_codec) const; virtual int ReceiveCodec(CodecInst* current_codec) const OVERRIDE;
// Incoming packet from network parsed and ready for decode. // Incoming packet from network parsed and ready for decode.
int IncomingPacket(const uint8_t* incoming_payload, virtual int IncomingPacket(const uint8_t* incoming_payload,
int payload_length, int payload_length,
const WebRtcRTPHeader& rtp_info); const WebRtcRTPHeader& rtp_info) OVERRIDE;
// Incoming payloads, without rtp-info, the rtp-info will be created in ACM. // Incoming payloads, without rtp-info, the rtp-info will be created in ACM.
// One usage for this API is when pre-encoded files are pushed in ACM. // One usage for this API is when pre-encoded files are pushed in ACM.
int IncomingPayload(const uint8_t* incoming_payload, virtual int IncomingPayload(const uint8_t* incoming_payload,
int payload_length, int payload_length,
uint8_t payload_type, uint8_t payload_type,
uint32_t timestamp); uint32_t timestamp) OVERRIDE;
// Minimum playout delay. // Minimum playout delay.
int SetMinimumPlayoutDelay(int time_ms); virtual int SetMinimumPlayoutDelay(int time_ms) OVERRIDE;
// Maximum playout delay. // Maximum playout delay.
int SetMaximumPlayoutDelay(int time_ms); virtual int SetMaximumPlayoutDelay(int time_ms) OVERRIDE;
// Smallest latency NetEq will maintain. // Smallest latency NetEq will maintain.
int LeastRequiredDelayMs() const; virtual int LeastRequiredDelayMs() const OVERRIDE;
// Impose an initial delay on playout. ACM plays silence until |delay_ms| // Impose an initial delay on playout. ACM plays silence until |delay_ms|
// audio is accumulated in NetEq buffer, then starts decoding payloads. // audio is accumulated in NetEq buffer, then starts decoding payloads.
int SetInitialPlayoutDelay(int delay_ms); virtual int SetInitialPlayoutDelay(int delay_ms) OVERRIDE;
// TODO(turajs): DTMF playout is always activated in NetEq these APIs should // TODO(turajs): DTMF playout is always activated in NetEq these APIs should
// be removed, as well as all VoE related APIs and methods. // be removed, as well as all VoE related APIs and methods.
// //
// Configure Dtmf playout status i.e on/off playout the incoming outband Dtmf // Configure Dtmf playout status i.e on/off playout the incoming outband Dtmf
// tone. // tone.
int SetDtmfPlayoutStatus(bool enable) { return 0; } virtual int SetDtmfPlayoutStatus(bool enable) OVERRIDE { return 0; }
// Get Dtmf playout status. // Get Dtmf playout status.
bool DtmfPlayoutStatus() const { return true; } virtual bool DtmfPlayoutStatus() const OVERRIDE { return true; }
// Estimate the Bandwidth based on the incoming stream, needed // Estimate the Bandwidth based on the incoming stream, needed
// for one way audio where the RTCP send the BW estimate. // for one way audio where the RTCP send the BW estimate.
// This is also done in the RTP module . // This is also done in the RTP module .
int DecoderEstimatedBandwidth() const; virtual int DecoderEstimatedBandwidth() const OVERRIDE;
// Set playout mode voice, fax. // Set playout mode voice, fax.
int SetPlayoutMode(AudioPlayoutMode mode); virtual int SetPlayoutMode(AudioPlayoutMode mode) OVERRIDE;
// Get playout mode voice, fax. // Get playout mode voice, fax.
AudioPlayoutMode PlayoutMode() const; virtual AudioPlayoutMode PlayoutMode() const OVERRIDE;
// Get playout timestamp. // Get playout timestamp.
int PlayoutTimestamp(uint32_t* timestamp); virtual int PlayoutTimestamp(uint32_t* timestamp) OVERRIDE;
// Get 10 milliseconds of raw audio data to play out, and // Get 10 milliseconds of raw audio data to play out, and
// automatic resample to the requested frequency if > 0. // automatic resample to the requested frequency if > 0.
int PlayoutData10Ms(int desired_freq_hz, AudioFrame* audio_frame); virtual int PlayoutData10Ms(int desired_freq_hz,
AudioFrame* audio_frame) OVERRIDE;
///////////////////////////////////////// /////////////////////////////////////////
// Statistics // Statistics
// //
int NetworkStatistics(ACMNetworkStatistics* statistics); virtual int NetworkStatistics(ACMNetworkStatistics* statistics) OVERRIDE;
// GET RED payload for iSAC. The method id called when 'this' ACM is // GET RED payload for iSAC. The method id called when 'this' ACM is
// the default ACM. // the default ACM.
@ -218,31 +222,34 @@ class AudioCodingModuleImpl : public AudioCodingModule {
uint8_t* payload, uint8_t* payload,
int16_t* length_bytes); int16_t* length_bytes);
int ReplaceInternalDTXWithWebRtc(bool use_webrtc_dtx); virtual int ReplaceInternalDTXWithWebRtc(bool use_webrtc_dtx) OVERRIDE;
int IsInternalDTXReplacedWithWebRtc(bool* uses_webrtc_dtx); virtual int IsInternalDTXReplacedWithWebRtc(bool* uses_webrtc_dtx) OVERRIDE;
int SetISACMaxRate(int max_bit_per_sec); virtual int SetISACMaxRate(int max_bit_per_sec) OVERRIDE;
int SetISACMaxPayloadSize(int max_size_bytes); virtual int SetISACMaxPayloadSize(int max_size_bytes) OVERRIDE;
int ConfigISACBandwidthEstimator(int frame_size_ms, virtual int ConfigISACBandwidthEstimator(
int rate_bit_per_sec, int frame_size_ms,
bool enforce_frame_size = false); int rate_bit_per_sec,
bool enforce_frame_size = false) OVERRIDE;
// If current send codec is Opus, informs it about the maximum playback rate // If current send codec is Opus, informs it about the maximum playback rate
// the receiver will render. // the receiver will render.
int SetOpusMaxPlaybackRate(int frequency_hz); virtual int SetOpusMaxPlaybackRate(int frequency_hz) OVERRIDE;
int UnregisterReceiveCodec(uint8_t payload_type); virtual int UnregisterReceiveCodec(uint8_t payload_type) OVERRIDE;
int EnableNack(size_t max_nack_list_size); virtual int EnableNack(size_t max_nack_list_size) OVERRIDE;
void DisableNack(); virtual void DisableNack() OVERRIDE;
std::vector<uint16_t> GetNackList(int round_trip_time_ms) const; virtual std::vector<uint16_t> GetNackList(
int round_trip_time_ms) const OVERRIDE;
void GetDecodingCallStatistics(AudioDecodingCallStats* stats) const; virtual void GetDecodingCallStatistics(
AudioDecodingCallStats* stats) const OVERRIDE;
private: private:
int UnregisterReceiveCodecSafe(int payload_type); int UnregisterReceiveCodecSafe(int payload_type);

6
webrtc/modules/audio_conference_mixer/interface/audio_conference_mixer.h
View File

@ -40,9 +40,9 @@ public:
virtual ~AudioConferenceMixer() {} virtual ~AudioConferenceMixer() {}
// Module functions // Module functions
virtual int32_t ChangeUniqueId(const int32_t id) = 0; virtual int32_t ChangeUniqueId(const int32_t id) OVERRIDE = 0;
virtual int32_t TimeUntilNextProcess() = 0 ; virtual int32_t TimeUntilNextProcess() OVERRIDE = 0;
virtual int32_t Process() = 0; virtual int32_t Process() OVERRIDE = 0;
// Register/unregister a callback class for receiving the mixed audio. // Register/unregister a callback class for receiving the mixed audio.
virtual int32_t RegisterMixedStreamCallback( virtual int32_t RegisterMixedStreamCallback(

24
webrtc/modules/audio_conference_mixer/source/audio_conference_mixer_impl.h
View File

@ -64,27 +64,27 @@ public:
bool Init(); bool Init();
// Module functions // Module functions
virtual int32_t ChangeUniqueId(const int32_t id); virtual int32_t ChangeUniqueId(const int32_t id) OVERRIDE;
virtual int32_t TimeUntilNextProcess(); virtual int32_t TimeUntilNextProcess() OVERRIDE;
virtual int32_t Process(); virtual int32_t Process() OVERRIDE;
// AudioConferenceMixer functions // AudioConferenceMixer functions
virtual int32_t RegisterMixedStreamCallback( virtual int32_t RegisterMixedStreamCallback(
AudioMixerOutputReceiver& mixReceiver); AudioMixerOutputReceiver& mixReceiver) OVERRIDE;
virtual int32_t UnRegisterMixedStreamCallback(); virtual int32_t UnRegisterMixedStreamCallback() OVERRIDE;
virtual int32_t RegisterMixerStatusCallback( virtual int32_t RegisterMixerStatusCallback(
AudioMixerStatusReceiver& mixerStatusCallback, AudioMixerStatusReceiver& mixerStatusCallback,
const uint32_t amountOf10MsBetweenCallbacks); const uint32_t amountOf10MsBetweenCallbacks) OVERRIDE;
virtual int32_t UnRegisterMixerStatusCallback(); virtual int32_t UnRegisterMixerStatusCallback() OVERRIDE;
virtual int32_t SetMixabilityStatus(MixerParticipant& participant, virtual int32_t SetMixabilityStatus(MixerParticipant& participant,
bool mixable); bool mixable) OVERRIDE;
virtual int32_t MixabilityStatus(MixerParticipant& participant, virtual int32_t MixabilityStatus(MixerParticipant& participant,
bool& mixable); bool& mixable) OVERRIDE;
virtual int32_t SetMinimumMixingFrequency(Frequency freq); virtual int32_t SetMinimumMixingFrequency(Frequency freq) OVERRIDE;
virtual int32_t SetAnonymousMixabilityStatus( virtual int32_t SetAnonymousMixabilityStatus(
MixerParticipant& participant, const bool mixable); MixerParticipant& participant, const bool mixable) OVERRIDE;
virtual int32_t AnonymousMixabilityStatus( virtual int32_t AnonymousMixabilityStatus(
MixerParticipant& participant, bool& mixable); MixerParticipant& participant, bool& mixable) OVERRIDE;
private: private:
enum{DEFAULT_AUDIO_FRAME_POOLSIZE = 50}; enum{DEFAULT_AUDIO_FRAME_POOLSIZE = 50};

2
webrtc/modules/media_file/interface/media_file.h
View File

@ -27,7 +27,7 @@ public:
static void DestroyMediaFile(MediaFile* module); static void DestroyMediaFile(MediaFile* module);
// Set the MediaFile instance identifier. // Set the MediaFile instance identifier.
virtual int32_t ChangeUniqueId(const int32_t id) = 0; virtual int32_t ChangeUniqueId(const int32_t id) OVERRIDE = 0;
// Put 10-60ms of audio data from file into the audioBuffer depending on // Put 10-60ms of audio data from file into the audioBuffer depending on
// codec frame size. dataLengthInBytes is both an input and output // codec frame size. dataLengthInBytes is both an input and output

73
webrtc/modules/media_file/source/media_file_impl.h
View File

@ -26,16 +26,18 @@ public:
MediaFileImpl(const int32_t id); MediaFileImpl(const int32_t id);
~MediaFileImpl(); ~MediaFileImpl();
int32_t ChangeUniqueId(const int32_t id); virtual int32_t ChangeUniqueId(const int32_t id) OVERRIDE;
int32_t Process(); virtual int32_t Process() OVERRIDE;
int32_t TimeUntilNextProcess(); virtual int32_t TimeUntilNextProcess() OVERRIDE;
// MediaFile functions // MediaFile functions
int32_t PlayoutAudioData(int8_t* audioBuffer, uint32_t& dataLengthInBytes); virtual int32_t PlayoutAudioData(int8_t* audioBuffer,
int32_t PlayoutAVIVideoData(int8_t* videoBuffer, uint32_t& dataLengthInBytes) OVERRIDE;
uint32_t& dataLengthInBytes); virtual int32_t PlayoutAVIVideoData(int8_t* videoBuffer,
int32_t PlayoutStereoData(int8_t* audioBufferLeft, int8_t* audioBufferRight, uint32_t& dataLengthInBytes) OVERRIDE;
uint32_t& dataLengthInBytes); virtual int32_t PlayoutStereoData(int8_t* audioBufferLeft,
int8_t* audioBufferRight,
uint32_t& dataLengthInBytes) OVERRIDE;
virtual int32_t StartPlayingAudioFile( virtual int32_t StartPlayingAudioFile(
const char* fileName, const char* fileName,
const uint32_t notificationTimeMs = 0, const uint32_t notificationTimeMs = 0,
@ -43,51 +45,52 @@ public:
const FileFormats format = kFileFormatPcm16kHzFile, const FileFormats format = kFileFormatPcm16kHzFile,
const CodecInst* codecInst = NULL, const CodecInst* codecInst = NULL,
const uint32_t startPointMs = 0, const uint32_t startPointMs = 0,
const uint32_t stopPointMs = 0); const uint32_t stopPointMs = 0) OVERRIDE;
int32_t StartPlayingVideoFile(const char* fileName, const bool loop, virtual int32_t StartPlayingVideoFile(const char* fileName, const bool loop,
bool videoOnly, const FileFormats format); bool videoOnly,
int32_t StartPlayingAudioStream(InStream& stream, const FileFormats format) OVERRIDE;
virtual int32_t StartPlayingAudioStream(InStream& stream,
const uint32_t notificationTimeMs = 0, const uint32_t notificationTimeMs = 0,
const FileFormats format = kFileFormatPcm16kHzFile, const FileFormats format = kFileFormatPcm16kHzFile,
const CodecInst* codecInst = NULL, const CodecInst* codecInst = NULL,
const uint32_t startPointMs = 0, const uint32_t startPointMs = 0,
const uint32_t stopPointMs = 0); const uint32_t stopPointMs = 0) OVERRIDE;
int32_t StopPlaying(); virtual int32_t StopPlaying() OVERRIDE;
bool IsPlaying(); virtual bool IsPlaying() OVERRIDE;
int32_t PlayoutPositionMs(uint32_t& positionMs) const; virtual int32_t PlayoutPositionMs(uint32_t& positionMs) const OVERRIDE;
int32_t IncomingAudioData(const int8_t* audioBuffer, virtual int32_t IncomingAudioData(const int8_t* audioBuffer,
const uint32_t bufferLength); const uint32_t bufferLength) OVERRIDE;
int32_t IncomingAVIVideoData(const int8_t* audioBuffer, virtual int32_t IncomingAVIVideoData(const int8_t* audioBuffer,
const uint32_t bufferLength); const uint32_t bufferLength) OVERRIDE;
int32_t StartRecordingAudioFile( virtual int32_t StartRecordingAudioFile(
const char* fileName, const char* fileName,
const FileFormats format, const FileFormats format,
const CodecInst& codecInst, const CodecInst& codecInst,
const uint32_t notificationTimeMs = 0, const uint32_t notificationTimeMs = 0,
const uint32_t maxSizeBytes = 0); const uint32_t maxSizeBytes = 0) OVERRIDE;
int32_t StartRecordingVideoFile( virtual int32_t StartRecordingVideoFile(
const char* fileName, const char* fileName,
const FileFormats format, const FileFormats format,
const CodecInst& codecInst, const CodecInst& codecInst,
const VideoCodec& videoCodecInst, const VideoCodec& videoCodecInst,
bool videoOnly = false); bool videoOnly = false) OVERRIDE;
int32_t StartRecordingAudioStream( virtual int32_t StartRecordingAudioStream(
OutStream& stream, OutStream& stream,
const FileFormats format, const FileFormats format,
const CodecInst& codecInst, const CodecInst& codecInst,
const uint32_t notificationTimeMs = 0); const uint32_t notificationTimeMs = 0) OVERRIDE;
int32_t StopRecording(); virtual int32_t StopRecording() OVERRIDE;
bool IsRecording(); virtual bool IsRecording() OVERRIDE;
int32_t RecordDurationMs(uint32_t& durationMs); virtual int32_t RecordDurationMs(uint32_t& durationMs) OVERRIDE;
bool IsStereo(); virtual bool IsStereo() OVERRIDE;
int32_t SetModuleFileCallback(FileCallback* callback); virtual int32_t SetModuleFileCallback(FileCallback* callback) OVERRIDE;
int32_t FileDurationMs( virtual int32_t FileDurationMs(
const char* fileName, const char* fileName,
uint32_t& durationMs, uint32_t& durationMs,
const FileFormats format, const FileFormats format,
const uint32_t freqInHz = 16000); const uint32_t freqInHz = 16000) OVERRIDE;
int32_t codec_info(CodecInst& codecInst) const; virtual int32_t codec_info(CodecInst& codecInst) const OVERRIDE;
int32_t VideoCodecInst(VideoCodec& codecInst) const; virtual int32_t VideoCodecInst(VideoCodec& codecInst) const OVERRIDE;
private: private:
// Returns true if the combination of format and codecInst is valid. // Returns true if the combination of format and codecInst is valid.

6
webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.cc
View File

@ -100,12 +100,6 @@ RTPReceiverStrategy* RtpReceiverImpl::GetMediaReceiver() const {
return rtp_media_receiver_.get(); return rtp_media_receiver_.get();
} }
RtpVideoCodecTypes RtpReceiverImpl::VideoCodecType() const {
PayloadUnion media_specific;
rtp_media_receiver_->GetLastMediaSpecificPayload(&media_specific);
return media_specific.Video.videoCodecType;
}
int32_t RtpReceiverImpl::RegisterReceivePayload( int32_t RtpReceiverImpl::RegisterReceivePayload(
const char payload_name[RTP_PAYLOAD_NAME_SIZE], const char payload_name[RTP_PAYLOAD_NAME_SIZE],
const int8_t payload_type, const int8_t payload_type,

2
webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.h
View File

@ -79,8 +79,6 @@ class RtpReceiverImpl : public RtpReceiver {
private: private:
bool HaveReceivedFrame() const; bool HaveReceivedFrame() const;
RtpVideoCodecTypes VideoCodecType() const;
void CheckSSRCChanged(const RTPHeader& rtp_header); void CheckSSRCChanged(const RTPHeader& rtp_header);
void CheckCSRC(const WebRtcRTPHeader& rtp_header); void CheckCSRC(const WebRtcRTPHeader& rtp_header);
int32_t CheckPayloadChanged(const RTPHeader& rtp_header, int32_t CheckPayloadChanged(const RTPHeader& rtp_header,

4
webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
View File

@ -1034,10 +1034,6 @@ int32_t ModuleRtpRtcpImpl::SendREDPayloadType(
return rtp_sender_.RED(&payload_type); return rtp_sender_.RED(&payload_type);
} }
RtpVideoCodecTypes ModuleRtpRtcpImpl::SendVideoCodec() const {
return rtp_sender_.VideoCodecType();
}
void ModuleRtpRtcpImpl::SetTargetSendBitrate( void ModuleRtpRtcpImpl::SetTargetSendBitrate(
const std::vector<uint32_t>& stream_bitrates) { const std::vector<uint32_t>& stream_bitrates) {
if (IsDefaultModule()) { if (IsDefaultModule()) {

26
webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
View File

@ -42,7 +42,7 @@ class ModuleRtpRtcpImpl : public RtpRtcp {
virtual int32_t IncomingRtcpPacket(const uint8_t* incoming_packet, virtual int32_t IncomingRtcpPacket(const uint8_t* incoming_packet,
uint16_t incoming_packet_length) OVERRIDE; uint16_t incoming_packet_length) OVERRIDE;
virtual void SetRemoteSSRC(const uint32_t ssrc); virtual void SetRemoteSSRC(const uint32_t ssrc) OVERRIDE;
// Sender part. // Sender part.
@ -52,7 +52,7 @@ class ModuleRtpRtcpImpl : public RtpRtcp {
virtual int32_t DeRegisterSendPayload(const int8_t payload_type) OVERRIDE; virtual int32_t DeRegisterSendPayload(const int8_t payload_type) OVERRIDE;
virtual int8_t SendPayloadType() const; int8_t SendPayloadType() const;
// Register RTP header extension. // Register RTP header extension.
virtual int32_t RegisterSendRtpHeaderExtension( virtual int32_t RegisterSendRtpHeaderExtension(
@ -89,9 +89,9 @@ class ModuleRtpRtcpImpl : public RtpRtcp {
virtual int32_t SetCSRCStatus(const bool include) OVERRIDE; virtual int32_t SetCSRCStatus(const bool include) OVERRIDE;
virtual RTCPSender::FeedbackState GetFeedbackState(); RTCPSender::FeedbackState GetFeedbackState();
virtual int CurrentSendFrequencyHz() const; int CurrentSendFrequencyHz() const;
virtual void SetRTXSendStatus(const int mode) OVERRIDE; virtual void SetRTXSendStatus(const int mode) OVERRIDE;
@ -295,8 +295,6 @@ class ModuleRtpRtcpImpl : public RtpRtcp {
// Video part. // Video part.
virtual RtpVideoCodecTypes SendVideoCodec() const;
virtual int32_t SendRTCPSliceLossIndication( virtual int32_t SendRTCPSliceLossIndication(
const uint8_t picture_id) OVERRIDE; const uint8_t picture_id) OVERRIDE;
@ -326,11 +324,11 @@ class ModuleRtpRtcpImpl : public RtpRtcp {
const FecProtectionParams* delta_params, const FecProtectionParams* delta_params,
const FecProtectionParams* key_params) OVERRIDE; const FecProtectionParams* key_params) OVERRIDE;
virtual bool LastReceivedNTP(uint32_t* NTPsecs, bool LastReceivedNTP(uint32_t* NTPsecs,
uint32_t* NTPfrac, uint32_t* NTPfrac,
uint32_t* remote_sr) const; uint32_t* remote_sr) const;
virtual bool LastReceivedXrReferenceTimeInfo(RtcpReceiveTimeInfo* info) const; bool LastReceivedXrReferenceTimeInfo(RtcpReceiveTimeInfo* info) const;
virtual int32_t BoundingSet(bool& tmmbr_owner, TMMBRSet*& bounding_set_rec); virtual int32_t BoundingSet(bool& tmmbr_owner, TMMBRSet*& bounding_set_rec);
@ -339,18 +337,18 @@ class ModuleRtpRtcpImpl : public RtpRtcp {
uint32_t* fec_rate, uint32_t* fec_rate,
uint32_t* nackRate) const OVERRIDE; uint32_t* nackRate) const OVERRIDE;
virtual uint32_t SendTimeOfSendReport(const uint32_t send_report); uint32_t SendTimeOfSendReport(const uint32_t send_report);
virtual bool SendTimeOfXrRrReport(uint32_t mid_ntp, int64_t* time_ms) const; bool SendTimeOfXrRrReport(uint32_t mid_ntp, int64_t* time_ms) const;
// Good state of RTP receiver inform sender. // Good state of RTP receiver inform sender.
virtual int32_t SendRTCPReferencePictureSelection( virtual int32_t SendRTCPReferencePictureSelection(
const uint64_t picture_id) OVERRIDE; const uint64_t picture_id) OVERRIDE;
virtual void RegisterSendChannelRtpStatisticsCallback( virtual void RegisterSendChannelRtpStatisticsCallback(
StreamDataCountersCallback* callback); StreamDataCountersCallback* callback) OVERRIDE;
virtual StreamDataCountersCallback* virtual StreamDataCountersCallback*
GetSendChannelRtpStatisticsCallback() const; GetSendChannelRtpStatisticsCallback() const OVERRIDE;
void OnReceivedTMMBR(); void OnReceivedTMMBR();

30
webrtc/modules/video_coding/main/source/video_coding_impl.cc
View File

@ -131,8 +131,8 @@ class VideoCodingModuleImpl : public VideoCodingModule {
externalEncoder, payloadType, internalSource); externalEncoder, payloadType, internalSource);
} }
virtual int32_t CodecConfigParameters(uint8_t* buffer, int32_t size) virtual int32_t CodecConfigParameters(uint8_t* buffer,
OVERRIDE { int32_t size) OVERRIDE {
return sender_->CodecConfigParameters(buffer, size); return sender_->CodecConfigParameters(buffer, size);
} }
@ -150,8 +150,8 @@ class VideoCodingModuleImpl : public VideoCodingModule {
return sender_->SetChannelParameters(target_bitrate, lossRate, rtt); return sender_->SetChannelParameters(target_bitrate, lossRate, rtt);
} }
virtual int32_t RegisterTransportCallback(VCMPacketizationCallback* transport) virtual int32_t RegisterTransportCallback(
OVERRIDE { VCMPacketizationCallback* transport) OVERRIDE {
return sender_->RegisterTransportCallback(transport); return sender_->RegisterTransportCallback(transport);
} }
@ -165,8 +165,8 @@ class VideoCodingModuleImpl : public VideoCodingModule {
return sender_->RegisterVideoQMCallback(videoQMSettings); return sender_->RegisterVideoQMCallback(videoQMSettings);
} }
virtual int32_t RegisterProtectionCallback(VCMProtectionCallback* protection) virtual int32_t RegisterProtectionCallback(
OVERRIDE { VCMProtectionCallback* protection) OVERRIDE {
return sender_->RegisterProtectionCallback(protection); return sender_->RegisterProtectionCallback(protection);
} }
@ -181,10 +181,10 @@ class VideoCodingModuleImpl : public VideoCodingModule {
return sender_return; return sender_return;
} }
virtual int32_t AddVideoFrame(const I420VideoFrame& videoFrame, virtual int32_t AddVideoFrame(
const VideoContentMetrics* contentMetrics, const I420VideoFrame& videoFrame,
const CodecSpecificInfo* codecSpecificInfo) const VideoContentMetrics* contentMetrics,
OVERRIDE { const CodecSpecificInfo* codecSpecificInfo) OVERRIDE {
return sender_->AddVideoFrame( return sender_->AddVideoFrame(
videoFrame, contentMetrics, codecSpecificInfo); videoFrame, contentMetrics, codecSpecificInfo);
} }
@ -226,11 +226,11 @@ class VideoCodingModuleImpl : public VideoCodingModule {
return VCM_OK; return VCM_OK;
} }
virtual void SuspendBelowMinBitrate() { virtual void SuspendBelowMinBitrate() OVERRIDE {
return sender_->SuspendBelowMinBitrate(); return sender_->SuspendBelowMinBitrate();
} }
virtual bool VideoSuspended() const { virtual bool VideoSuspended() const OVERRIDE {
return sender_->VideoSuspended(); return sender_->VideoSuspended();
} }
@ -252,8 +252,8 @@ class VideoCodingModuleImpl : public VideoCodingModule {
externalDecoder, payloadType, internalRenderTiming); externalDecoder, payloadType, internalRenderTiming);
} }
virtual int32_t RegisterReceiveCallback(VCMReceiveCallback* receiveCallback) virtual int32_t RegisterReceiveCallback(
OVERRIDE { VCMReceiveCallback* receiveCallback) OVERRIDE {
return receiver_->RegisterReceiveCallback(receiveCallback); return receiver_->RegisterReceiveCallback(receiveCallback);
} }
@ -292,7 +292,7 @@ class VideoCodingModuleImpl : public VideoCodingModule {
virtual int32_t ResetDecoder() OVERRIDE { return receiver_->ResetDecoder(); } virtual int32_t ResetDecoder() OVERRIDE { return receiver_->ResetDecoder(); }
virtual int32_t ReceiveCodec(VideoCodec* currentReceiveCodec) const { virtual int32_t ReceiveCodec(VideoCodec* currentReceiveCodec) const OVERRIDE {
return receiver_->ReceiveCodec(currentReceiveCodec); return receiver_->ReceiveCodec(currentReceiveCodec);
} }

4
webrtc/modules/video_processing/main/interface/video_processing.h
View File

@ -89,12 +89,12 @@ class VideoProcessingModule : public Module {
/** /**
Not supported. Not supported.
*/ */
virtual int32_t TimeUntilNextProcess() { return -1; } virtual int32_t TimeUntilNextProcess() OVERRIDE { return -1; }
/** /**
Not supported. Not supported.
*/ */
virtual int32_t Process() { return -1; } virtual int32_t Process() OVERRIDE { return -1; }
/** /**
Resets all processing components to their initial states. This should be Resets all processing components to their initial states. This should be

28
webrtc/modules/video_processing/main/source/video_processing_impl.h
View File

@ -29,43 +29,45 @@ class VideoProcessingModuleImpl : public VideoProcessingModule {
int32_t Id() const; int32_t Id() const;
virtual int32_t ChangeUniqueId(const int32_t id); virtual int32_t ChangeUniqueId(const int32_t id) OVERRIDE;
virtual void Reset(); virtual void Reset() OVERRIDE;
virtual int32_t Deflickering(I420VideoFrame* frame, FrameStats* stats); virtual int32_t Deflickering(I420VideoFrame* frame,
FrameStats* stats) OVERRIDE;
virtual int32_t BrightnessDetection(const I420VideoFrame& frame, virtual int32_t BrightnessDetection(const I420VideoFrame& frame,
const FrameStats& stats); const FrameStats& stats) OVERRIDE;
// Frame pre-processor functions // Frame pre-processor functions
// Enable temporal decimation // Enable temporal decimation
virtual void EnableTemporalDecimation(bool enable); virtual void EnableTemporalDecimation(bool enable) OVERRIDE;
virtual void SetInputFrameResampleMode(VideoFrameResampling resampling_mode); virtual void SetInputFrameResampleMode(
VideoFrameResampling resampling_mode) OVERRIDE;
// Enable content analysis // Enable content analysis
virtual void EnableContentAnalysis(bool enable); virtual void EnableContentAnalysis(bool enable) OVERRIDE;
// Set Target Resolution: frame rate and dimension // Set Target Resolution: frame rate and dimension
virtual int32_t SetTargetResolution(uint32_t width, virtual int32_t SetTargetResolution(uint32_t width,
uint32_t height, uint32_t height,
uint32_t frame_rate); uint32_t frame_rate) OVERRIDE;
// Get decimated values: frame rate/dimension // Get decimated values: frame rate/dimension
virtual uint32_t Decimatedframe_rate(); virtual uint32_t Decimatedframe_rate() OVERRIDE;
virtual uint32_t DecimatedWidth() const; virtual uint32_t DecimatedWidth() const OVERRIDE;
virtual uint32_t DecimatedHeight() const; virtual uint32_t DecimatedHeight() const OVERRIDE;
// Preprocess: // Preprocess:
// Pre-process incoming frame: Sample when needed and compute content // Pre-process incoming frame: Sample when needed and compute content
// metrics when enabled. // metrics when enabled.
// If no resampling takes place - processed_frame is set to NULL. // If no resampling takes place - processed_frame is set to NULL.
virtual int32_t PreprocessFrame(const I420VideoFrame& frame, virtual int32_t PreprocessFrame(const I420VideoFrame& frame,
I420VideoFrame** processed_frame); I420VideoFrame** processed_frame) OVERRIDE;
virtual VideoContentMetrics* ContentMetrics() const; virtual VideoContentMetrics* ContentMetrics() const OVERRIDE;
private: private:
int32_t id_; int32_t id_;

6
webrtc/modules/video_render/include/video_render.h
View File

@ -61,10 +61,10 @@ public:
* *
* id - new unique identifier of this video render module object * id - new unique identifier of this video render module object
*/ */
virtual int32_t ChangeUniqueId(const int32_t id) = 0; virtual int32_t ChangeUniqueId(const int32_t id) OVERRIDE = 0;
virtual int32_t TimeUntilNextProcess() = 0; virtual int32_t TimeUntilNextProcess() OVERRIDE = 0;
virtual int32_t Process() = 0; virtual int32_t Process() OVERRIDE = 0;
/************************************************************************** /**************************************************************************
* *

4
webrtc/video_engine/call_stats.h
View File

@ -32,8 +32,8 @@ class CallStats : public Module {
~CallStats(); ~CallStats();
// Implements Module, to use the process thread. // Implements Module, to use the process thread.
virtual int32_t TimeUntilNextProcess(); virtual int32_t TimeUntilNextProcess() OVERRIDE;
virtual int32_t Process(); virtual int32_t Process() OVERRIDE;
// Returns a RtcpRttStats to register at a statistics provider. The object // Returns a RtcpRttStats to register at a statistics provider. The object
// has the same lifetime as the CallStats instance. // has the same lifetime as the CallStats instance.

33
webrtc/video_engine/test/libvietest/include/tb_I420_codec.h
View File

@ -24,33 +24,28 @@ public:
TbI420Encoder(); TbI420Encoder();
virtual ~TbI420Encoder(); virtual ~TbI420Encoder();
static int32_t VersionStatic(char* version, int32_t length);
virtual int32_t Version(char* version, int32_t length) const;
virtual int32_t InitEncode(const webrtc::VideoCodec* codecSettings, virtual int32_t InitEncode(const webrtc::VideoCodec* codecSettings,
int32_t numberOfCores, int32_t numberOfCores,
uint32_t maxPayloadSize); uint32_t maxPayloadSize) OVERRIDE;
virtual int32_t Encode( virtual int32_t Encode(
const webrtc::I420VideoFrame& inputImage, const webrtc::I420VideoFrame& inputImage,
const webrtc::CodecSpecificInfo* codecSpecificInfo, const webrtc::CodecSpecificInfo* codecSpecificInfo,
const std::vector<webrtc::VideoFrameType>* frameTypes); const std::vector<webrtc::VideoFrameType>* frameTypes) OVERRIDE;
virtual int32_t RegisterEncodeCompleteCallback( virtual int32_t RegisterEncodeCompleteCallback(
webrtc::EncodedImageCallback* callback); webrtc::EncodedImageCallback* callback) OVERRIDE;
virtual int32_t Release(); virtual int32_t Release() OVERRIDE;
virtual int32_t Reset(); virtual int32_t SetChannelParameters(uint32_t packetLoss, int rtt) OVERRIDE;
virtual int32_t SetChannelParameters(uint32_t packetLoss, int rtt); virtual int32_t SetRates(uint32_t newBitRate, uint32_t frameRate) OVERRIDE;
virtual int32_t SetRates(uint32_t newBitRate, uint32_t frameRate); virtual int32_t SetPeriodicKeyFrames(bool enable) OVERRIDE;
virtual int32_t SetPeriodicKeyFrames(bool enable);
virtual int32_t CodecConfigParameters(uint8_t* /*buffer*/, virtual int32_t CodecConfigParameters(uint8_t* /*buffer*/,
int32_t /*size*/); int32_t /*size*/) OVERRIDE;
struct FunctionCalls struct FunctionCalls
{ {
@ -87,18 +82,18 @@ public:
virtual ~TbI420Decoder(); virtual ~TbI420Decoder();
virtual int32_t InitDecode(const webrtc::VideoCodec* inst, virtual int32_t InitDecode(const webrtc::VideoCodec* inst,
int32_t numberOfCores); int32_t numberOfCores) OVERRIDE;
virtual int32_t Decode( virtual int32_t Decode(
const webrtc::EncodedImage& inputImage, const webrtc::EncodedImage& inputImage,
bool missingFrames, bool missingFrames,
const webrtc::RTPFragmentationHeader* fragmentation, const webrtc::RTPFragmentationHeader* fragmentation,
const webrtc::CodecSpecificInfo* codecSpecificInfo = NULL, const webrtc::CodecSpecificInfo* codecSpecificInfo = NULL,
int64_t renderTimeMs = -1); int64_t renderTimeMs = -1) OVERRIDE;
virtual int32_t virtual int32_t RegisterDecodeCompleteCallback(
RegisterDecodeCompleteCallback(webrtc::DecodedImageCallback* callback); webrtc::DecodedImageCallback* callback) OVERRIDE;
virtual int32_t Release(); virtual int32_t Release() OVERRIDE;
virtual int32_t Reset(); virtual int32_t Reset() OVERRIDE;
struct FunctionCalls struct FunctionCalls
{ {

29
webrtc/video_engine/test/libvietest/testbed/tb_I420_codec.cc
View File

@ -12,7 +12,6 @@
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
#include <string.h>
#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h" #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
@ -33,23 +32,6 @@ TbI420Encoder::~TbI420Encoder()
} }
} }
int32_t TbI420Encoder::VersionStatic(char* version, int32_t length)
{
const char* str = "I420 version 1.0.0\n";
int32_t verLen = (int32_t) strlen(str);
if (verLen > length)
{
return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
}
strncpy(version, str, length);
return verLen;
}
int32_t TbI420Encoder::Version(char* version, int32_t length) const
{
return VersionStatic(version, length);
}
int32_t TbI420Encoder::Release() int32_t TbI420Encoder::Release()
{ {
_functionCalls.Release++; _functionCalls.Release++;
@ -64,17 +46,6 @@ int32_t TbI420Encoder::Release()
return WEBRTC_VIDEO_CODEC_OK; return WEBRTC_VIDEO_CODEC_OK;
} }
int32_t TbI420Encoder::Reset()
{
_functionCalls.Reset++;
if (!_inited)
{
return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
}
return WEBRTC_VIDEO_CODEC_OK;
}
int32_t TbI420Encoder::SetChannelParameters(uint32_t packetLoss, int rtt) { int32_t TbI420Encoder::SetChannelParameters(uint32_t packetLoss, int rtt) {
_functionCalls.SetChannelParameters++; _functionCalls.SetChannelParameters++;
return WEBRTC_VIDEO_CODEC_OK; return WEBRTC_VIDEO_CODEC_OK;

14
webrtc/video_engine/vie_channel_group.cc
View File

@ -54,39 +54,39 @@ class WrappingBitrateEstimator : public RemoteBitrateEstimator {
virtual void IncomingPacket(int64_t arrival_time_ms, virtual void IncomingPacket(int64_t arrival_time_ms,
int payload_size, int payload_size,
const RTPHeader& header) { const RTPHeader& header) OVERRIDE {
CriticalSectionScoped cs(crit_sect_.get()); CriticalSectionScoped cs(crit_sect_.get());
PickEstimatorFromHeader(header); PickEstimatorFromHeader(header);
rbe_->IncomingPacket(arrival_time_ms, payload_size, header); rbe_->IncomingPacket(arrival_time_ms, payload_size, header);
} }
virtual int32_t Process() { virtual int32_t Process() OVERRIDE {
CriticalSectionScoped cs(crit_sect_.get()); CriticalSectionScoped cs(crit_sect_.get());
return rbe_->Process(); return rbe_->Process();
} }
virtual int32_t TimeUntilNextProcess() { virtual int32_t TimeUntilNextProcess() OVERRIDE {
CriticalSectionScoped cs(crit_sect_.get()); CriticalSectionScoped cs(crit_sect_.get());
return rbe_->TimeUntilNextProcess(); return rbe_->TimeUntilNextProcess();
} }
virtual void OnRttUpdate(uint32_t rtt) { virtual void OnRttUpdate(uint32_t rtt) OVERRIDE {
CriticalSectionScoped cs(crit_sect_.get()); CriticalSectionScoped cs(crit_sect_.get());
rbe_->OnRttUpdate(rtt); rbe_->OnRttUpdate(rtt);
} }
virtual void RemoveStream(unsigned int ssrc) { virtual void RemoveStream(unsigned int ssrc) OVERRIDE {
CriticalSectionScoped cs(crit_sect_.get()); CriticalSectionScoped cs(crit_sect_.get());
rbe_->RemoveStream(ssrc); rbe_->RemoveStream(ssrc);
} }
virtual bool LatestEstimate(std::vector<unsigned int>* ssrcs, virtual bool LatestEstimate(std::vector<unsigned int>* ssrcs,
unsigned int* bitrate_bps) const { unsigned int* bitrate_bps) const OVERRIDE {
CriticalSectionScoped cs(crit_sect_.get()); CriticalSectionScoped cs(crit_sect_.get());
return rbe_->LatestEstimate(ssrcs, bitrate_bps); return rbe_->LatestEstimate(ssrcs, bitrate_bps);
} }
virtual bool GetStats(ReceiveBandwidthEstimatorStats* output) const { virtual bool GetStats(ReceiveBandwidthEstimatorStats* output) const OVERRIDE {
CriticalSectionScoped cs(crit_sect_.get()); CriticalSectionScoped cs(crit_sect_.get());
return rbe_->GetStats(output); return rbe_->GetStats(output);
} }

4
webrtc/video_engine/vie_sync_module.h
View File

@ -45,8 +45,8 @@ class ViESyncModule : public Module {
int SetTargetBufferingDelay(int target_delay_ms); int SetTargetBufferingDelay(int target_delay_ms);
// Implements Module. // Implements Module.
virtual int32_t TimeUntilNextProcess(); virtual int32_t TimeUntilNextProcess() OVERRIDE;
virtual int32_t Process(); virtual int32_t Process() OVERRIDE;
private: private:
scoped_ptr<CriticalSectionWrapper> data_cs_; scoped_ptr<CriticalSectionWrapper> data_cs_;

8
webrtc/voice_engine/monitor_module.cc
View File

@ -52,14 +52,6 @@ MonitorModule::DeRegisterObserver()
return 0; return 0;
} }
int32_t
MonitorModule::Version(char* version,
uint32_t& remainingBufferInBytes,
uint32_t& position) const
{
return 0;
}
int32_t int32_t
MonitorModule::ChangeUniqueId(int32_t id) MonitorModule::ChangeUniqueId(int32_t id)
{ {

10
webrtc/voice_engine/monitor_module.h
View File

@ -40,15 +40,11 @@ public:
virtual ~MonitorModule(); virtual ~MonitorModule();
public: // module public: // module
int32_t Version(char* version, virtual int32_t ChangeUniqueId(int32_t id) OVERRIDE;
uint32_t& remainingBufferInBytes,
uint32_t& position) const;
int32_t ChangeUniqueId(int32_t id); virtual int32_t TimeUntilNextProcess() OVERRIDE;
int32_t TimeUntilNextProcess(); virtual int32_t Process() OVERRIDE;
int32_t Process();
private: private:
enum { kAverageProcessUpdateTimeMs = 1000 }; enum { kAverageProcessUpdateTimeMs = 1000 };
MonitorObserver* _observerPtr; MonitorObserver* _observerPtr;