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_;
}
int32_t FakeAudioCaptureModule::Version(char* /*version*/,
uint32_t& /*remaining_buffer_in_bytes*/,
uint32_t& /*position*/) const {
ASSERT(false);
return 0;
}
int32_t FakeAudioCaptureModule::TimeUntilNextProcess() {
const uint32 current_time = rtc::Time();
if (current_time < last_process_time_ms_) {
@ -325,12 +318,6 @@ int32_t FakeAudioCaptureModule::WaveOutVolume(
return 0;
}
int32_t FakeAudioCaptureModule::SpeakerIsAvailable(bool* available) {
// No speaker, just dropping audio. Return success.
*available = true;
return 0;
}
int32_t FakeAudioCaptureModule::InitSpeaker() {
// No speaker, just playing from file. Return success.
return 0;
@ -341,12 +328,6 @@ bool FakeAudioCaptureModule::SpeakerIsInitialized() const {
return 0;
}
int32_t FakeAudioCaptureModule::MicrophoneIsAvailable(bool* available) {
// No microphone, just playing from file. Return success.
*available = true;
return 0;
}
int32_t FakeAudioCaptureModule::InitMicrophone() {
// No microphone, just playing from file. Return success.
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
// 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.
virtual int32_t Version(char* version,
uint32_t& remaining_buffer_in_bytes,
uint32_t& position) const;
virtual int32_t TimeUntilNextProcess();
virtual int32_t Process();
virtual int32_t ChangeUniqueId(const int32_t id);
virtual int32_t TimeUntilNextProcess() OVERRIDE;
virtual int32_t Process() OVERRIDE;
virtual int32_t ChangeUniqueId(const int32_t id) OVERRIDE;
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(
webrtc::AudioDeviceObserver* event_callback);
webrtc::AudioDeviceObserver* event_callback) OVERRIDE;
// 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 Terminate();
virtual bool Initialized() const;
virtual int32_t Init() OVERRIDE;
virtual int32_t Terminate() OVERRIDE;
virtual bool Initialized() const OVERRIDE;
virtual int16_t PlayoutDevices();
virtual int16_t RecordingDevices();
virtual int32_t PlayoutDeviceName(uint16_t index,
char name[webrtc::kAdmMaxDeviceNameSize],
char guid[webrtc::kAdmMaxGuidSize]);
virtual int32_t RecordingDeviceName(uint16_t index,
char name[webrtc::kAdmMaxDeviceNameSize],
char guid[webrtc::kAdmMaxGuidSize]);
virtual int16_t PlayoutDevices() OVERRIDE;
virtual int16_t RecordingDevices() OVERRIDE;
virtual int32_t PlayoutDeviceName(
uint16_t index,
char name[webrtc::kAdmMaxDeviceNameSize],
char guid[webrtc::kAdmMaxGuidSize]) OVERRIDE;
virtual int32_t RecordingDeviceName(
uint16_t index,
char name[webrtc::kAdmMaxDeviceNameSize],
char guid[webrtc::kAdmMaxGuidSize]) OVERRIDE;
virtual int32_t SetPlayoutDevice(uint16_t index);
virtual int32_t SetPlayoutDevice(WindowsDeviceType device);
virtual int32_t SetRecordingDevice(uint16_t index);
virtual int32_t SetRecordingDevice(WindowsDeviceType device);
virtual int32_t SetPlayoutDevice(uint16_t index) OVERRIDE;
virtual int32_t SetPlayoutDevice(WindowsDeviceType device) OVERRIDE;
virtual int32_t SetRecordingDevice(uint16_t index) OVERRIDE;
virtual int32_t SetRecordingDevice(WindowsDeviceType device) OVERRIDE;
virtual int32_t PlayoutIsAvailable(bool* available);
virtual int32_t InitPlayout();
virtual bool PlayoutIsInitialized() const;
virtual int32_t RecordingIsAvailable(bool* available);
virtual int32_t InitRecording();
virtual bool RecordingIsInitialized() const;
virtual int32_t PlayoutIsAvailable(bool* available) OVERRIDE;
virtual int32_t InitPlayout() OVERRIDE;
virtual bool PlayoutIsInitialized() const OVERRIDE;
virtual int32_t RecordingIsAvailable(bool* available) OVERRIDE;
virtual int32_t InitRecording() OVERRIDE;
virtual bool RecordingIsInitialized() const OVERRIDE;
virtual int32_t StartPlayout();
virtual int32_t StopPlayout();
virtual bool Playing() const;
virtual int32_t StartRecording();
virtual int32_t StopRecording();
virtual bool Recording() const;
virtual int32_t StartPlayout() OVERRIDE;
virtual int32_t StopPlayout() OVERRIDE;
virtual bool Playing() const OVERRIDE;
virtual int32_t StartRecording() OVERRIDE;
virtual int32_t StopRecording() OVERRIDE;
virtual bool Recording() const OVERRIDE;
virtual int32_t SetAGC(bool enable);
virtual bool AGC() const;
virtual int32_t SetAGC(bool enable) OVERRIDE;
virtual bool AGC() const OVERRIDE;
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,
uint16_t* volume_right) const;
uint16_t* volume_right) const OVERRIDE;
virtual int32_t SpeakerIsAvailable(bool* available);
virtual int32_t InitSpeaker();
virtual bool SpeakerIsInitialized() const;
virtual int32_t MicrophoneIsAvailable(bool* available);
virtual int32_t InitMicrophone();
virtual bool MicrophoneIsInitialized() const;
virtual int32_t InitSpeaker() OVERRIDE;
virtual bool SpeakerIsInitialized() const OVERRIDE;
virtual int32_t InitMicrophone() OVERRIDE;
virtual bool MicrophoneIsInitialized() const OVERRIDE;
virtual int32_t SpeakerVolumeIsAvailable(bool* available);
virtual int32_t SetSpeakerVolume(uint32_t volume);
virtual int32_t SpeakerVolume(uint32_t* volume) const;
virtual int32_t MaxSpeakerVolume(uint32_t* max_volume) const;
virtual int32_t MinSpeakerVolume(uint32_t* min_volume) const;
virtual int32_t SpeakerVolumeStepSize(uint16_t* step_size) const;
virtual int32_t SpeakerVolumeIsAvailable(bool* available) OVERRIDE;
virtual int32_t SetSpeakerVolume(uint32_t volume) OVERRIDE;
virtual int32_t SpeakerVolume(uint32_t* volume) const OVERRIDE;
virtual int32_t MaxSpeakerVolume(uint32_t* max_volume) const OVERRIDE;
virtual int32_t MinSpeakerVolume(uint32_t* min_volume) const OVERRIDE;
virtual int32_t SpeakerVolumeStepSize(uint16_t* step_size) const OVERRIDE;
virtual int32_t MicrophoneVolumeIsAvailable(bool* available);
virtual int32_t SetMicrophoneVolume(uint32_t volume);
virtual int32_t MicrophoneVolume(uint32_t* volume) const;
virtual int32_t MaxMicrophoneVolume(uint32_t* max_volume) const;
virtual int32_t MicrophoneVolumeIsAvailable(bool* available) OVERRIDE;
virtual int32_t SetMicrophoneVolume(uint32_t volume) OVERRIDE;
virtual int32_t MicrophoneVolume(uint32_t* volume) const OVERRIDE;
virtual int32_t MaxMicrophoneVolume(uint32_t* max_volume) const OVERRIDE;
virtual int32_t MinMicrophoneVolume(uint32_t* min_volume) const;
virtual int32_t MicrophoneVolumeStepSize(uint16_t* step_size) const;
virtual int32_t MinMicrophoneVolume(uint32_t* min_volume) const OVERRIDE;
virtual int32_t MicrophoneVolumeStepSize(uint16_t* step_size) const OVERRIDE;
virtual int32_t SpeakerMuteIsAvailable(bool* available);
virtual int32_t SetSpeakerMute(bool enable);
virtual int32_t SpeakerMute(bool* enabled) const;
virtual int32_t SpeakerMuteIsAvailable(bool* available) OVERRIDE;
virtual int32_t SetSpeakerMute(bool enable) OVERRIDE;
virtual int32_t SpeakerMute(bool* enabled) const OVERRIDE;
virtual int32_t MicrophoneMuteIsAvailable(bool* available);
virtual int32_t SetMicrophoneMute(bool enable);
virtual int32_t MicrophoneMute(bool* enabled) const;
virtual int32_t MicrophoneMuteIsAvailable(bool* available) OVERRIDE;
virtual int32_t SetMicrophoneMute(bool enable) OVERRIDE;
virtual int32_t MicrophoneMute(bool* enabled) const OVERRIDE;
virtual int32_t MicrophoneBoostIsAvailable(bool* available);
virtual int32_t SetMicrophoneBoost(bool enable);
virtual int32_t MicrophoneBoost(bool* enabled) const;
virtual int32_t MicrophoneBoostIsAvailable(bool* available) OVERRIDE;
virtual int32_t SetMicrophoneBoost(bool enable) OVERRIDE;
virtual int32_t MicrophoneBoost(bool* enabled) const OVERRIDE;
virtual int32_t StereoPlayoutIsAvailable(bool* available) const;
virtual int32_t SetStereoPlayout(bool enable);
virtual int32_t StereoPlayout(bool* enabled) const;
virtual int32_t StereoRecordingIsAvailable(bool* available) const;
virtual int32_t SetStereoRecording(bool enable);
virtual int32_t StereoRecording(bool* enabled) const;
virtual int32_t SetRecordingChannel(const ChannelType channel);
virtual int32_t RecordingChannel(ChannelType* channel) const;
virtual int32_t StereoPlayoutIsAvailable(bool* available) const OVERRIDE;
virtual int32_t SetStereoPlayout(bool enable) OVERRIDE;
virtual int32_t StereoPlayout(bool* enabled) const OVERRIDE;
virtual int32_t StereoRecordingIsAvailable(bool* available) const OVERRIDE;
virtual int32_t SetStereoRecording(bool enable) OVERRIDE;
virtual int32_t StereoRecording(bool* enabled) const OVERRIDE;
virtual int32_t SetRecordingChannel(const ChannelType channel) OVERRIDE;
virtual int32_t RecordingChannel(ChannelType* channel) const OVERRIDE;
virtual int32_t SetPlayoutBuffer(const BufferType type,
uint16_t size_ms = 0);
uint16_t size_ms = 0) OVERRIDE;
virtual int32_t PlayoutBuffer(BufferType* type,
uint16_t* size_ms) const;
virtual int32_t PlayoutDelay(uint16_t* delay_ms) const;
virtual int32_t RecordingDelay(uint16_t* delay_ms) const;
uint16_t* size_ms) const OVERRIDE;
virtual int32_t PlayoutDelay(uint16_t* delay_ms) const OVERRIDE;
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(
const char pcm_file_name_utf8[webrtc::kAdmMaxFileNameSize]);
virtual int32_t StopRawOutputFileRecording();
const char pcm_file_name_utf8[webrtc::kAdmMaxFileNameSize]) OVERRIDE;
virtual int32_t StopRawOutputFileRecording() OVERRIDE;
virtual int32_t StartRawInputFileRecording(
const char pcm_file_name_utf8[webrtc::kAdmMaxFileNameSize]);
virtual int32_t StopRawInputFileRecording();
const char pcm_file_name_utf8[webrtc::kAdmMaxFileNameSize]) OVERRIDE;
virtual int32_t StopRawInputFileRecording() OVERRIDE;
virtual int32_t SetRecordingSampleRate(const uint32_t samples_per_sec);
virtual int32_t RecordingSampleRate(uint32_t* samples_per_sec) const;
virtual int32_t SetPlayoutSampleRate(const uint32_t samples_per_sec);
virtual int32_t PlayoutSampleRate(uint32_t* samples_per_sec) const;
virtual int32_t SetRecordingSampleRate(
const uint32_t samples_per_sec) OVERRIDE;
virtual int32_t RecordingSampleRate(uint32_t* samples_per_sec) const OVERRIDE;
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 SetLoudspeakerStatus(bool enable);
virtual int32_t GetLoudspeakerStatus(bool* enabled) const;
virtual int32_t ResetAudioDevice() OVERRIDE;
virtual int32_t SetLoudspeakerStatus(bool enable) OVERRIDE;
virtual int32_t GetLoudspeakerStatus(bool* enabled) const OVERRIDE;
// End of functions inherited from webrtc::AudioDeviceModule.
// The following function is inherited from rtc::MessageHandler.
virtual void OnMessage(rtc::Message* msg);
virtual void OnMessage(rtc::Message* msg) OVERRIDE;
protected:
// 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) {
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;
EXPECT_EQ(0,
fake_audio_capture_module_->StereoPlayoutIsAvailable(
@ -182,11 +177,6 @@ TEST_F(FakeAdmTest, PlayoutTest) {
TEST_F(FakeAdmTest, RecordTest) {
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;
EXPECT_EQ(0, fake_audio_capture_module_->StereoRecordingIsAvailable(
&stereo_available));

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

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

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

@ -41,26 +41,20 @@ class WebRtcPassthroughRender : public webrtc::VideoRender {
WebRtcPassthroughRender();
virtual ~WebRtcPassthroughRender();
virtual int32_t Version(int8_t* version,
uint32_t& remainingBufferInBytes,
uint32_t& position) const {
virtual int32_t ChangeUniqueId(const int32_t id) OVERRIDE {
return 0;
}
virtual int32_t ChangeUniqueId(const int32_t id) {
return 0;
}
virtual int32_t TimeUntilNextProcess() OVERRIDE { return 0; }
virtual int32_t TimeUntilNextProcess() { return 0; }
virtual int32_t Process() OVERRIDE { return 0; }
virtual int32_t Process() { return 0; }
virtual void* Window() {
virtual void* Window() OVERRIDE {
rtc::CritScope cs(&render_critical_);
return window_;
}
virtual int32_t ChangeWindow(void* window) {
virtual int32_t ChangeWindow(void* window) OVERRIDE {
rtc::CritScope cs(&render_critical_);
window_ = window;
return 0;
@ -70,64 +64,60 @@ class WebRtcPassthroughRender : public webrtc::VideoRender {
const uint32_t stream_id,
const uint32_t zOrder,
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(
const uint32_t stream_id,
webrtc::VideoRenderCallback* render_object);
webrtc::VideoRenderCallback* render_object) OVERRIDE;
virtual int32_t GetIncomingRenderStreamProperties(
const uint32_t stream_id,
uint32_t& zOrder,
float& left, float& top,
float& right, float& bottom) const {
float& right, float& bottom) const OVERRIDE {
return -1;
}
virtual uint32_t GetIncomingFrameRate(
const uint32_t stream_id) {
virtual uint32_t GetIncomingFrameRate(const uint32_t stream_id) OVERRIDE {
return 0;
}
virtual uint32_t GetNumIncomingRenderStreams() const {
virtual uint32_t GetNumIncomingRenderStreams() const OVERRIDE {
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(
const uint32_t stream_id,
webrtc::VideoRenderCallback* callback_obj) {
webrtc::VideoRenderCallback* callback_obj) OVERRIDE {
return -1;
}
virtual int32_t GetLastRenderedFrame(
const uint32_t stream_id,
webrtc::I420VideoFrame &frame) const {
webrtc::I420VideoFrame &frame) const OVERRIDE {
return -1;
}
virtual int32_t StartRender(
const uint32_t stream_id);
virtual int32_t StartRender(const uint32_t stream_id) OVERRIDE;
virtual int32_t StopRender(
const uint32_t stream_id);
virtual int32_t StopRender(const uint32_t stream_id) OVERRIDE;
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,
uint32_t& screenHeight) const {
uint32_t& screenHeight) const OVERRIDE {
return -1;
}
virtual uint32_t RenderFrameRate(
const uint32_t stream_id) {
virtual uint32_t RenderFrameRate(const uint32_t stream_id) OVERRIDE {
return 0;
}
@ -135,11 +125,12 @@ class WebRtcPassthroughRender : public webrtc::VideoRender {
const uint32_t stream_id,
const float left, const float top,
const float right,
const float bottom) {
const float bottom) OVERRIDE {
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;
}
@ -148,22 +139,22 @@ class WebRtcPassthroughRender : public webrtc::VideoRender {
const unsigned int zOrder,
const float left, const float top,
const float right,
const float bottom) {
const float bottom) OVERRIDE {
return -1;
}
virtual int32_t SetTransparentBackground(const bool enable) {
virtual int32_t SetTransparentBackground(const bool enable) OVERRIDE {
return -1;
}
virtual int32_t FullScreenRender(void* window, const bool enable) {
virtual int32_t FullScreenRender(void* window, const bool enable) OVERRIDE {
return -1;
}
virtual int32_t SetBitmap(const void* bitMap,
const uint8_t pictureId, const void* colorKey,
const float left, const float top,
const float right, const float bottom) {
const float right, const float bottom) OVERRIDE {
return -1;
}
@ -173,27 +164,27 @@ class WebRtcPassthroughRender : public webrtc::VideoRender {
const uint32_t textColorRef,
const uint32_t backgroundColorRef,
const float left, const float top,
const float right, const float bottom) {
const float right, const float bottom) OVERRIDE {
return -1;
}
virtual int32_t SetStartImage(
const uint32_t stream_id,
const webrtc::I420VideoFrame& videoFrame) {
const webrtc::I420VideoFrame& videoFrame) OVERRIDE {
return -1;
}
virtual int32_t SetTimeoutImage(
const uint32_t stream_id,
const webrtc::I420VideoFrame& videoFrame,
const uint32_t timeout) {
const uint32_t timeout) OVERRIDE {
return -1;
}
virtual int32_t MirrorRenderStream(const int renderId,
const bool enable,
const bool mirrorXAxis,
const bool mirrorYAxis) {
const bool mirrorYAxis) OVERRIDE {
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();
// 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
// to call Process.
int32_t TimeUntilNextProcess();
virtual int32_t TimeUntilNextProcess() OVERRIDE;
// Process any pending tasks such as timeouts.
int32_t Process();
virtual int32_t Process() OVERRIDE;
/////////////////////////////////////////
// Sender
//
// Initialize send codec.
int InitializeSender();
virtual int InitializeSender() OVERRIDE;
// Reset send codec.
int ResetEncoder();
virtual int ResetEncoder() OVERRIDE;
// 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
// 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
// deregistering secondary codec.
void UnregisterSecondarySendCodec();
virtual void UnregisterSecondarySendCodec() OVERRIDE;
// Get the secondary codec.
int SecondarySendCodec(CodecInst* secondary_codec) const;
virtual int SecondarySendCodec(CodecInst* secondary_codec) const OVERRIDE;
// Get current send codec.
int SendCodec(CodecInst* current_codec) const;
virtual int SendCodec(CodecInst* current_codec) const OVERRIDE;
// Get current send frequency.
int SendFrequency() const;
virtual int SendFrequency() const OVERRIDE;
// Get encode bit-rate.
// Adaptive rate codecs return their current encode target rate, while other
// 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
// 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
// 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.
int Add10MsData(const AudioFrame& audio_frame);
virtual int Add10MsData(const AudioFrame& audio_frame) OVERRIDE;
/////////////////////////////////////////
// (RED) Redundant Coding
//
// Configure RED status i.e. on/off.
int SetREDStatus(bool enable_red);
virtual int SetREDStatus(bool enable_red) OVERRIDE;
// Get RED status.
bool REDStatus() const;
virtual bool REDStatus() const OVERRIDE;
/////////////////////////////////////////
// (FEC) Forward Error Correction (codec internal)
//
// Configure FEC status i.e. on/off.
int SetCodecFEC(bool enabled_codec_fec);
virtual int SetCodecFEC(bool enabled_codec_fec) OVERRIDE;
// Get FEC status.
bool CodecFEC() const;
virtual bool CodecFEC() const OVERRIDE;
// Set target packet loss rate
int SetPacketLossRate(int loss_rate);
virtual int SetPacketLossRate(int loss_rate) OVERRIDE;
/////////////////////////////////////////
// (VAD) Voice Activity Detection
@ -120,95 +121,98 @@ class AudioCodingModuleImpl : public AudioCodingModule {
// (CNG) Comfort Noise Generation
//
int SetVAD(bool enable_dtx = true,
bool enable_vad = false,
ACMVADMode mode = VADNormal);
virtual int SetVAD(bool enable_dtx = true,
bool enable_vad = false,
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
//
// Initialize receiver, resets codec database etc.
int InitializeReceiver();
virtual int InitializeReceiver() OVERRIDE;
// Reset the decoder state.
int ResetDecoder();
virtual int ResetDecoder() OVERRIDE;
// Get current receive frequency.
int ReceiveFrequency() const;
virtual int ReceiveFrequency() const OVERRIDE;
// Get current playout frequency.
int PlayoutFrequency() const;
virtual int PlayoutFrequency() const OVERRIDE;
// Register possible receive codecs, can be called multiple times,
// for codecs, CNG, DTMF, RED.
int RegisterReceiveCodec(const CodecInst& receive_codec);
virtual int RegisterReceiveCodec(const CodecInst& receive_codec) OVERRIDE;
// 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.
int IncomingPacket(const uint8_t* incoming_payload,
int payload_length,
const WebRtcRTPHeader& rtp_info);
virtual int IncomingPacket(const uint8_t* incoming_payload,
int payload_length,
const WebRtcRTPHeader& rtp_info) OVERRIDE;
// 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.
int IncomingPayload(const uint8_t* incoming_payload,
int payload_length,
uint8_t payload_type,
uint32_t timestamp);
virtual int IncomingPayload(const uint8_t* incoming_payload,
int payload_length,
uint8_t payload_type,
uint32_t timestamp) OVERRIDE;
// Minimum playout delay.
int SetMinimumPlayoutDelay(int time_ms);
virtual int SetMinimumPlayoutDelay(int time_ms) OVERRIDE;
// Maximum playout delay.
int SetMaximumPlayoutDelay(int time_ms);
virtual int SetMaximumPlayoutDelay(int time_ms) OVERRIDE;
// 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|
// 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
// be removed, as well as all VoE related APIs and methods.
//
// Configure Dtmf playout status i.e on/off playout the incoming outband Dtmf
// tone.
int SetDtmfPlayoutStatus(bool enable) { return 0; }
virtual int SetDtmfPlayoutStatus(bool enable) OVERRIDE { return 0; }
// 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
// for one way audio where the RTCP send the BW estimate.
// This is also done in the RTP module .
int DecoderEstimatedBandwidth() const;
virtual int DecoderEstimatedBandwidth() const OVERRIDE;
// Set playout mode voice, fax.
int SetPlayoutMode(AudioPlayoutMode mode);
virtual int SetPlayoutMode(AudioPlayoutMode mode) OVERRIDE;
// Get playout mode voice, fax.
AudioPlayoutMode PlayoutMode() const;
virtual AudioPlayoutMode PlayoutMode() const OVERRIDE;
// 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
// 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
//
int NetworkStatistics(ACMNetworkStatistics* statistics);
virtual int NetworkStatistics(ACMNetworkStatistics* statistics) OVERRIDE;
// GET RED payload for iSAC. The method id called when 'this' ACM is
// the default ACM.
@ -218,31 +222,34 @@ class AudioCodingModuleImpl : public AudioCodingModule {
uint8_t* payload,
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,
int rate_bit_per_sec,
bool enforce_frame_size = false);
virtual int ConfigISACBandwidthEstimator(
int frame_size_ms,
int rate_bit_per_sec,
bool enforce_frame_size = false) OVERRIDE;
// If current send codec is Opus, informs it about the maximum playback rate
// 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:
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() {}
// Module functions
virtual int32_t ChangeUniqueId(const int32_t id) = 0;
virtual int32_t TimeUntilNextProcess() = 0 ;
virtual int32_t Process() = 0;
virtual int32_t ChangeUniqueId(const int32_t id) OVERRIDE = 0;
virtual int32_t TimeUntilNextProcess() OVERRIDE = 0;
virtual int32_t Process() OVERRIDE = 0;
// Register/unregister a callback class for receiving the mixed audio.
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();
// Module functions
virtual int32_t ChangeUniqueId(const int32_t id);
virtual int32_t TimeUntilNextProcess();
virtual int32_t Process();
virtual int32_t ChangeUniqueId(const int32_t id) OVERRIDE;
virtual int32_t TimeUntilNextProcess() OVERRIDE;
virtual int32_t Process() OVERRIDE;
// AudioConferenceMixer functions
virtual int32_t RegisterMixedStreamCallback(
AudioMixerOutputReceiver& mixReceiver);
virtual int32_t UnRegisterMixedStreamCallback();
AudioMixerOutputReceiver& mixReceiver) OVERRIDE;
virtual int32_t UnRegisterMixedStreamCallback() OVERRIDE;
virtual int32_t RegisterMixerStatusCallback(
AudioMixerStatusReceiver& mixerStatusCallback,
const uint32_t amountOf10MsBetweenCallbacks);
virtual int32_t UnRegisterMixerStatusCallback();
const uint32_t amountOf10MsBetweenCallbacks) OVERRIDE;
virtual int32_t UnRegisterMixerStatusCallback() OVERRIDE;
virtual int32_t SetMixabilityStatus(MixerParticipant& participant,
bool mixable);
bool mixable) OVERRIDE;
virtual int32_t MixabilityStatus(MixerParticipant& participant,
bool& mixable);
virtual int32_t SetMinimumMixingFrequency(Frequency freq);
bool& mixable) OVERRIDE;
virtual int32_t SetMinimumMixingFrequency(Frequency freq) OVERRIDE;
virtual int32_t SetAnonymousMixabilityStatus(
MixerParticipant& participant, const bool mixable);
MixerParticipant& participant, const bool mixable) OVERRIDE;
virtual int32_t AnonymousMixabilityStatus(
MixerParticipant& participant, bool& mixable);
MixerParticipant& participant, bool& mixable) OVERRIDE;
private:
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);
// 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
// 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();
int32_t ChangeUniqueId(const int32_t id);
int32_t Process();
int32_t TimeUntilNextProcess();
virtual int32_t ChangeUniqueId(const int32_t id) OVERRIDE;
virtual int32_t Process() OVERRIDE;
virtual int32_t TimeUntilNextProcess() OVERRIDE;
// MediaFile functions
int32_t PlayoutAudioData(int8_t* audioBuffer, uint32_t& dataLengthInBytes);
int32_t PlayoutAVIVideoData(int8_t* videoBuffer,
uint32_t& dataLengthInBytes);
int32_t PlayoutStereoData(int8_t* audioBufferLeft, int8_t* audioBufferRight,
uint32_t& dataLengthInBytes);
virtual int32_t PlayoutAudioData(int8_t* audioBuffer,
uint32_t& dataLengthInBytes) OVERRIDE;
virtual int32_t PlayoutAVIVideoData(int8_t* videoBuffer,
uint32_t& dataLengthInBytes) OVERRIDE;
virtual int32_t PlayoutStereoData(int8_t* audioBufferLeft,
int8_t* audioBufferRight,
uint32_t& dataLengthInBytes) OVERRIDE;
virtual int32_t StartPlayingAudioFile(
const char* fileName,
const uint32_t notificationTimeMs = 0,
@ -43,51 +45,52 @@ public:
const FileFormats format = kFileFormatPcm16kHzFile,
const CodecInst* codecInst = NULL,
const uint32_t startPointMs = 0,
const uint32_t stopPointMs = 0);
int32_t StartPlayingVideoFile(const char* fileName, const bool loop,
bool videoOnly, const FileFormats format);
int32_t StartPlayingAudioStream(InStream& stream,
const uint32_t stopPointMs = 0) OVERRIDE;
virtual int32_t StartPlayingVideoFile(const char* fileName, const bool loop,
bool videoOnly,
const FileFormats format) OVERRIDE;
virtual int32_t StartPlayingAudioStream(InStream& stream,
const uint32_t notificationTimeMs = 0,
const FileFormats format = kFileFormatPcm16kHzFile,
const CodecInst* codecInst = NULL,
const uint32_t startPointMs = 0,
const uint32_t stopPointMs = 0);
int32_t StopPlaying();
bool IsPlaying();
int32_t PlayoutPositionMs(uint32_t& positionMs) const;
int32_t IncomingAudioData(const int8_t* audioBuffer,
const uint32_t bufferLength);
int32_t IncomingAVIVideoData(const int8_t* audioBuffer,
const uint32_t bufferLength);
int32_t StartRecordingAudioFile(
const uint32_t stopPointMs = 0) OVERRIDE;
virtual int32_t StopPlaying() OVERRIDE;
virtual bool IsPlaying() OVERRIDE;
virtual int32_t PlayoutPositionMs(uint32_t& positionMs) const OVERRIDE;
virtual int32_t IncomingAudioData(const int8_t* audioBuffer,
const uint32_t bufferLength) OVERRIDE;
virtual int32_t IncomingAVIVideoData(const int8_t* audioBuffer,
const uint32_t bufferLength) OVERRIDE;
virtual int32_t StartRecordingAudioFile(
const char* fileName,
const FileFormats format,
const CodecInst& codecInst,
const uint32_t notificationTimeMs = 0,
const uint32_t maxSizeBytes = 0);
int32_t StartRecordingVideoFile(
const uint32_t maxSizeBytes = 0) OVERRIDE;
virtual int32_t StartRecordingVideoFile(
const char* fileName,
const FileFormats format,
const CodecInst& codecInst,
const VideoCodec& videoCodecInst,
bool videoOnly = false);
int32_t StartRecordingAudioStream(
bool videoOnly = false) OVERRIDE;
virtual int32_t StartRecordingAudioStream(
OutStream& stream,
const FileFormats format,
const CodecInst& codecInst,
const uint32_t notificationTimeMs = 0);
int32_t StopRecording();
bool IsRecording();
int32_t RecordDurationMs(uint32_t& durationMs);
bool IsStereo();
int32_t SetModuleFileCallback(FileCallback* callback);
int32_t FileDurationMs(
const uint32_t notificationTimeMs = 0) OVERRIDE;
virtual int32_t StopRecording() OVERRIDE;
virtual bool IsRecording() OVERRIDE;
virtual int32_t RecordDurationMs(uint32_t& durationMs) OVERRIDE;
virtual bool IsStereo() OVERRIDE;
virtual int32_t SetModuleFileCallback(FileCallback* callback) OVERRIDE;
virtual int32_t FileDurationMs(
const char* fileName,
uint32_t& durationMs,
const FileFormats format,
const uint32_t freqInHz = 16000);
int32_t codec_info(CodecInst& codecInst) const;
int32_t VideoCodecInst(VideoCodec& codecInst) const;
const uint32_t freqInHz = 16000) OVERRIDE;
virtual int32_t codec_info(CodecInst& codecInst) const OVERRIDE;
virtual int32_t VideoCodecInst(VideoCodec& codecInst) const OVERRIDE;
private:
// 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();
}
RtpVideoCodecTypes RtpReceiverImpl::VideoCodecType() const {
PayloadUnion media_specific;
rtp_media_receiver_->GetLastMediaSpecificPayload(&media_specific);
return media_specific.Video.videoCodecType;
}
int32_t RtpReceiverImpl::RegisterReceivePayload(
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
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:
bool HaveReceivedFrame() const;
RtpVideoCodecTypes VideoCodecType() const;
void CheckSSRCChanged(const RTPHeader& rtp_header);
void CheckCSRC(const WebRtcRTPHeader& 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);
}
RtpVideoCodecTypes ModuleRtpRtcpImpl::SendVideoCodec() const {
return rtp_sender_.VideoCodecType();
}
void ModuleRtpRtcpImpl::SetTargetSendBitrate(
const std::vector<uint32_t>& stream_bitrates) {
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,
uint16_t incoming_packet_length) OVERRIDE;
virtual void SetRemoteSSRC(const uint32_t ssrc);
virtual void SetRemoteSSRC(const uint32_t ssrc) OVERRIDE;
// Sender part.
@ -52,7 +52,7 @@ class ModuleRtpRtcpImpl : public RtpRtcp {
virtual int32_t DeRegisterSendPayload(const int8_t payload_type) OVERRIDE;
virtual int8_t SendPayloadType() const;
int8_t SendPayloadType() const;
// Register RTP header extension.
virtual int32_t RegisterSendRtpHeaderExtension(
@ -89,9 +89,9 @@ class ModuleRtpRtcpImpl : public RtpRtcp {
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;
@ -295,8 +295,6 @@ class ModuleRtpRtcpImpl : public RtpRtcp {
// Video part.
virtual RtpVideoCodecTypes SendVideoCodec() const;
virtual int32_t SendRTCPSliceLossIndication(
const uint8_t picture_id) OVERRIDE;
@ -326,11 +324,11 @@ class ModuleRtpRtcpImpl : public RtpRtcp {
const FecProtectionParams* delta_params,
const FecProtectionParams* key_params) OVERRIDE;
virtual bool LastReceivedNTP(uint32_t* NTPsecs,
uint32_t* NTPfrac,
uint32_t* remote_sr) const;
bool LastReceivedNTP(uint32_t* NTPsecs,
uint32_t* NTPfrac,
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);
@ -339,18 +337,18 @@ class ModuleRtpRtcpImpl : public RtpRtcp {
uint32_t* fec_rate,
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.
virtual int32_t SendRTCPReferencePictureSelection(
const uint64_t picture_id) OVERRIDE;
virtual void RegisterSendChannelRtpStatisticsCallback(
StreamDataCountersCallback* callback);
StreamDataCountersCallback* callback) OVERRIDE;
virtual StreamDataCountersCallback*
GetSendChannelRtpStatisticsCallback() const;
GetSendChannelRtpStatisticsCallback() const OVERRIDE;
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);
}
virtual int32_t CodecConfigParameters(uint8_t* buffer, int32_t size)
OVERRIDE {
virtual int32_t CodecConfigParameters(uint8_t* buffer,
int32_t size) OVERRIDE {
return sender_->CodecConfigParameters(buffer, size);
}
@ -150,8 +150,8 @@ class VideoCodingModuleImpl : public VideoCodingModule {
return sender_->SetChannelParameters(target_bitrate, lossRate, rtt);
}
virtual int32_t RegisterTransportCallback(VCMPacketizationCallback* transport)
OVERRIDE {
virtual int32_t RegisterTransportCallback(
VCMPacketizationCallback* transport) OVERRIDE {
return sender_->RegisterTransportCallback(transport);
}
@ -165,8 +165,8 @@ class VideoCodingModuleImpl : public VideoCodingModule {
return sender_->RegisterVideoQMCallback(videoQMSettings);
}
virtual int32_t RegisterProtectionCallback(VCMProtectionCallback* protection)
OVERRIDE {
virtual int32_t RegisterProtectionCallback(
VCMProtectionCallback* protection) OVERRIDE {
return sender_->RegisterProtectionCallback(protection);
}
@ -181,10 +181,10 @@ class VideoCodingModuleImpl : public VideoCodingModule {
return sender_return;
}
virtual int32_t AddVideoFrame(const I420VideoFrame& videoFrame,
const VideoContentMetrics* contentMetrics,
const CodecSpecificInfo* codecSpecificInfo)
OVERRIDE {
virtual int32_t AddVideoFrame(
const I420VideoFrame& videoFrame,
const VideoContentMetrics* contentMetrics,
const CodecSpecificInfo* codecSpecificInfo) OVERRIDE {
return sender_->AddVideoFrame(
videoFrame, contentMetrics, codecSpecificInfo);
}
@ -226,11 +226,11 @@ class VideoCodingModuleImpl : public VideoCodingModule {
return VCM_OK;
}
virtual void SuspendBelowMinBitrate() {
virtual void SuspendBelowMinBitrate() OVERRIDE {
return sender_->SuspendBelowMinBitrate();
}
virtual bool VideoSuspended() const {
virtual bool VideoSuspended() const OVERRIDE {
return sender_->VideoSuspended();
}
@ -252,8 +252,8 @@ class VideoCodingModuleImpl : public VideoCodingModule {
externalDecoder, payloadType, internalRenderTiming);
}
virtual int32_t RegisterReceiveCallback(VCMReceiveCallback* receiveCallback)
OVERRIDE {
virtual int32_t RegisterReceiveCallback(
VCMReceiveCallback* receiveCallback) OVERRIDE {
return receiver_->RegisterReceiveCallback(receiveCallback);
}
@ -292,7 +292,7 @@ class VideoCodingModuleImpl : public VideoCodingModule {
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);
}

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

@ -89,12 +89,12 @@ class VideoProcessingModule : public Module {
/**
Not supported.
*/
virtual int32_t TimeUntilNextProcess() { return -1; }
virtual int32_t TimeUntilNextProcess() OVERRIDE { return -1; }
/**
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

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;
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,
const FrameStats& stats);
const FrameStats& stats) OVERRIDE;
// Frame pre-processor functions
// 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
virtual void EnableContentAnalysis(bool enable);
virtual void EnableContentAnalysis(bool enable) OVERRIDE;
// Set Target Resolution: frame rate and dimension
virtual int32_t SetTargetResolution(uint32_t width,
uint32_t height,
uint32_t frame_rate);
uint32_t frame_rate) OVERRIDE;
// Get decimated values: frame rate/dimension
virtual uint32_t Decimatedframe_rate();
virtual uint32_t DecimatedWidth() const;
virtual uint32_t DecimatedHeight() const;
virtual uint32_t Decimatedframe_rate() OVERRIDE;
virtual uint32_t DecimatedWidth() const OVERRIDE;
virtual uint32_t DecimatedHeight() const OVERRIDE;
// Preprocess:
// Pre-process incoming frame: Sample when needed and compute content
// metrics when enabled.
// If no resampling takes place - processed_frame is set to NULL.
virtual int32_t PreprocessFrame(const I420VideoFrame& frame,
I420VideoFrame** processed_frame);
virtual VideoContentMetrics* ContentMetrics() const;
I420VideoFrame** processed_frame) OVERRIDE;
virtual VideoContentMetrics* ContentMetrics() const OVERRIDE;
private:
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
*/
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 Process() = 0;
virtual int32_t TimeUntilNextProcess() OVERRIDE = 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();
// Implements Module, to use the process thread.
virtual int32_t TimeUntilNextProcess();
virtual int32_t Process();
virtual int32_t TimeUntilNextProcess() OVERRIDE;
virtual int32_t Process() OVERRIDE;
// Returns a RtcpRttStats to register at a statistics provider. The object
// 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();
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,
int32_t numberOfCores,
uint32_t maxPayloadSize);
uint32_t maxPayloadSize) OVERRIDE;
virtual int32_t Encode(
const webrtc::I420VideoFrame& inputImage,
const webrtc::CodecSpecificInfo* codecSpecificInfo,
const std::vector<webrtc::VideoFrameType>* frameTypes);
const std::vector<webrtc::VideoFrameType>* frameTypes) OVERRIDE;
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);
virtual int32_t SetPeriodicKeyFrames(bool enable) OVERRIDE;
virtual int32_t CodecConfigParameters(uint8_t* /*buffer*/,
int32_t /*size*/);
int32_t /*size*/) OVERRIDE;
struct FunctionCalls
{
@ -87,18 +82,18 @@ public:
virtual ~TbI420Decoder();
virtual int32_t InitDecode(const webrtc::VideoCodec* inst,
int32_t numberOfCores);
int32_t numberOfCores) OVERRIDE;
virtual int32_t Decode(
const webrtc::EncodedImage& inputImage,
bool missingFrames,
const webrtc::RTPFragmentationHeader* fragmentation,
const webrtc::CodecSpecificInfo* codecSpecificInfo = NULL,
int64_t renderTimeMs = -1);
int64_t renderTimeMs = -1) OVERRIDE;
virtual int32_t
RegisterDecodeCompleteCallback(webrtc::DecodedImageCallback* callback);
virtual int32_t Release();
virtual int32_t Reset();
virtual int32_t RegisterDecodeCompleteCallback(
webrtc::DecodedImageCallback* callback) OVERRIDE;
virtual int32_t Release() OVERRIDE;
virtual int32_t Reset() OVERRIDE;
struct FunctionCalls
{

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

@ -12,7 +12,6 @@
#include <assert.h>
#include <stdio.h>
#include <string.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()
{
_functionCalls.Release++;
@ -64,17 +46,6 @@ int32_t TbI420Encoder::Release()
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) {
_functionCalls.SetChannelParameters++;
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,
int payload_size,
const RTPHeader& header) {
const RTPHeader& header) OVERRIDE {
CriticalSectionScoped cs(crit_sect_.get());
PickEstimatorFromHeader(header);
rbe_->IncomingPacket(arrival_time_ms, payload_size, header);
}
virtual int32_t Process() {
virtual int32_t Process() OVERRIDE {
CriticalSectionScoped cs(crit_sect_.get());
return rbe_->Process();
}
virtual int32_t TimeUntilNextProcess() {
virtual int32_t TimeUntilNextProcess() OVERRIDE {
CriticalSectionScoped cs(crit_sect_.get());
return rbe_->TimeUntilNextProcess();
}
virtual void OnRttUpdate(uint32_t rtt) {
virtual void OnRttUpdate(uint32_t rtt) OVERRIDE {
CriticalSectionScoped cs(crit_sect_.get());
rbe_->OnRttUpdate(rtt);
}
virtual void RemoveStream(unsigned int ssrc) {
virtual void RemoveStream(unsigned int ssrc) OVERRIDE {
CriticalSectionScoped cs(crit_sect_.get());
rbe_->RemoveStream(ssrc);
}
virtual bool LatestEstimate(std::vector<unsigned int>* ssrcs,
unsigned int* bitrate_bps) const {
unsigned int* bitrate_bps) const OVERRIDE {
CriticalSectionScoped cs(crit_sect_.get());
return rbe_->LatestEstimate(ssrcs, bitrate_bps);
}
virtual bool GetStats(ReceiveBandwidthEstimatorStats* output) const {
virtual bool GetStats(ReceiveBandwidthEstimatorStats* output) const OVERRIDE {
CriticalSectionScoped cs(crit_sect_.get());
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);
// Implements Module.
virtual int32_t TimeUntilNextProcess();
virtual int32_t Process();
virtual int32_t TimeUntilNextProcess() OVERRIDE;
virtual int32_t Process() OVERRIDE;
private:
scoped_ptr<CriticalSectionWrapper> data_cs_;

8
webrtc/voice_engine/monitor_module.cc
View File

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

10
webrtc/voice_engine/monitor_module.h
View File

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