zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Roll chromium_revision e144d30..6fdb142 (318658:318841) + remove OVERRIDE macro

Browse Source 
Clang version changed 223108:230914
Details: e144d30..6fdb142/tools/clang/scripts/update.sh

Removes the OVERRIDE macro defined in:
* webrtc/base/common.h
* webrtc/typedefs.h

The majority of the source changes were done by running this in src/:
perl -0pi -e "s/virtual\s([^({;]*(\([^({;]*\)[^({;]*))(OVERRIDE|override)/\1override/sg" `find {talk,webrtc} -name "*.h"  -o -name "*.cc*" -o -name "*.mm*"`

which converted all:
virtual Foo() OVERRIDE
functions to:
Foo() override

Then I manually edited:
* talk/media/webrtc/fakewebrtccommon.h
* webrtc/test/fake_common.h

Remaining uses of OVERRIDE was fixed by search+replace.

Manual edits were done to fix virtual destructors that were
overriding inherited ones.

Finally a build error related to the pure virtual definitions of
Read, Write and Rewind in common_types.h required a bit of
refactoring in:
* webrtc/common_types.cc
* webrtc/common_types.h
* webrtc/system_wrappers/interface/file_wrapper.h
* webrtc/system_wrappers/source/file_impl.cc

This roll should make it possible for us to finally re-enable deadlock
detection for TSan on the buildbots.

BUG=4106
R=pbos@webrtc.org, tommi@webrtc.org

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

Cr-Commit-Position: refs/heads/master@{#8596}
git-svn-id: http://webrtc.googlecode.com/svn/trunk@8596 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
kjellander@webrtc.org
2015-03-04 12:58:35 +00:00
parent 792f1a14e2
commit 14665ff7d4
286 changed files with 3546 additions and 3920 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
webrtc/modules/video_coding/codecs/i420/main/interface/i420.h
View File

@ -34,9 +34,9 @@ class I420Encoder : public VideoEncoder {
//
// Return value : WEBRTC_VIDEO_CODEC_OK if OK.
// <0 - Error
virtual int InitEncode(const VideoCodec* codecSettings,
int /*numberOfCores*/,
size_t /*maxPayloadSize*/) OVERRIDE;
int InitEncode(const VideoCodec* codecSettings,
int /*numberOfCores*/,
size_t /*maxPayloadSize*/) override;
// "Encode" an I420 image (as a part of a video stream). The encoded image
// will be returned to the user via the encode complete callback.
@ -48,10 +48,9 @@ class I420Encoder : public VideoEncoder {
//
// Return value : WEBRTC_VIDEO_CODEC_OK if OK.
// <0 - Error
virtual int Encode(
const I420VideoFrame& inputImage,
const CodecSpecificInfo* /*codecSpecificInfo*/,
const std::vector<VideoFrameType>* /*frame_types*/) OVERRIDE;
int Encode(const I420VideoFrame& inputImage,
const CodecSpecificInfo* /*codecSpecificInfo*/,
const std::vector<VideoFrameType>* /*frame_types*/) override;
// Register an encode complete callback object.
//
@ -59,26 +58,22 @@ class I420Encoder : public VideoEncoder {
// - callback : Callback object which handles encoded images.
//
// Return value : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.
virtual int RegisterEncodeCompleteCallback(
EncodedImageCallback* callback) OVERRIDE;
int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
// Free encoder memory.
//
// Return value : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.
virtual int Release() OVERRIDE;
int Release() override;
virtual int SetRates(uint32_t /*newBitRate*/,
uint32_t /*frameRate*/) OVERRIDE {
int SetRates(uint32_t /*newBitRate*/, uint32_t /*frameRate*/) override {
return WEBRTC_VIDEO_CODEC_OK;
}
virtual int SetChannelParameters(uint32_t /*packetLoss*/,
int64_t /*rtt*/) OVERRIDE {
int SetChannelParameters(uint32_t /*packetLoss*/, int64_t /*rtt*/) override {
return WEBRTC_VIDEO_CODEC_OK;
}
virtual int CodecConfigParameters(uint8_t* /*buffer*/,
int /*size*/) OVERRIDE {
int CodecConfigParameters(uint8_t* /*buffer*/, int /*size*/) override {
return WEBRTC_VIDEO_CODEC_OK;
}
@ -102,11 +97,11 @@ class I420Decoder : public VideoDecoder {
//
// Return value : WEBRTC_VIDEO_CODEC_OK.
// <0 - Errors
virtual int InitDecode(const VideoCodec* codecSettings,
int /*numberOfCores*/) OVERRIDE;
int InitDecode(const VideoCodec* codecSettings,
int /*numberOfCores*/) override;
virtual int SetCodecConfigParameters(const uint8_t* /*buffer*/,
int /*size*/) OVERRIDE {
int SetCodecConfigParameters(const uint8_t* /*buffer*/,
int /*size*/) override {
return WEBRTC_VIDEO_CODEC_OK;
}
@ -122,11 +117,11 @@ class I420Decoder : public VideoDecoder {
//
// Return value : WEBRTC_VIDEO_CODEC_OK if OK
// <0 - Error
virtual int Decode(const EncodedImage& inputImage,
bool missingFrames,
const RTPFragmentationHeader* /*fragmentation*/,
const CodecSpecificInfo* /*codecSpecificInfo*/,
int64_t /*renderTimeMs*/) OVERRIDE;
int Decode(const EncodedImage& inputImage,
bool missingFrames,
const RTPFragmentationHeader* /*fragmentation*/,
const CodecSpecificInfo* /*codecSpecificInfo*/,
int64_t /*renderTimeMs*/) override;
// Register a decode complete callback object.
//
@ -134,20 +129,19 @@ class I420Decoder : public VideoDecoder {
// - callback : Callback object which handles decoded images.
//
// Return value : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.
virtual int RegisterDecodeCompleteCallback(
DecodedImageCallback* callback) OVERRIDE;
int RegisterDecodeCompleteCallback(DecodedImageCallback* callback) override;
// Free decoder memory.
//
// Return value : WEBRTC_VIDEO_CODEC_OK if OK.
// <0 - Error
virtual int Release() OVERRIDE;
int Release() override;
// Reset decoder state and prepare for a new call.
//
// Return value : WEBRTC_VIDEO_CODEC_OK.
// <0 - Error
virtual int Reset() OVERRIDE;
int Reset() override;
private:
static const uint8_t* ExtractHeader(const uint8_t* buffer,

2
webrtc/modules/video_coding/codecs/test/packet_manipulator.h
View File

@ -91,7 +91,7 @@ class PacketManipulatorImpl : public PacketManipulator {
const NetworkingConfig& config,
bool verbose);
virtual ~PacketManipulatorImpl();
virtual int ManipulatePackets(webrtc::EncodedImage* encoded_image) OVERRIDE;
int ManipulatePackets(webrtc::EncodedImage* encoded_image) override;
virtual void InitializeRandomSeed(unsigned int seed);
protected:
// Returns a uniformly distributed random value between 0.0 and 1.0

2
webrtc/modules/video_coding/codecs/test/predictive_packet_manipulator.h
View File

@ -33,7 +33,7 @@ class PredictivePacketManipulator : public PacketManipulatorImpl {
void AddRandomResult(double result);
protected:
// Returns a uniformly distributed random value between 0.0 and 1.0
virtual double RandomUniform() OVERRIDE;
double RandomUniform() override;
private:
std::queue<double> random_results_;

18
webrtc/modules/video_coding/codecs/test/videoprocessor.h
View File

@ -163,8 +163,8 @@ class VideoProcessorImpl : public VideoProcessor {
const TestConfig& config,
Stats* stats);
virtual ~VideoProcessorImpl();
virtual bool Init() OVERRIDE;
virtual bool ProcessFrame(int frame_number) OVERRIDE;
bool Init() override;
bool ProcessFrame(int frame_number) override;
private:
// Invoked by the callback when a frame has completed encoding.
@ -176,13 +176,13 @@ class VideoProcessorImpl : public VideoProcessor {
int GetElapsedTimeMicroseconds(const webrtc::TickTime& start,
const webrtc::TickTime& stop);
// Updates the encoder with the target bit rate and the frame rate.
virtual void SetRates(int bit_rate, int frame_rate) OVERRIDE;
void SetRates(int bit_rate, int frame_rate) override;
// Return the size of the encoded frame in bytes.
virtual size_t EncodedFrameSize() OVERRIDE;
size_t EncodedFrameSize() override;
// Return the number of dropped frames.
virtual int NumberDroppedFrames() OVERRIDE;
int NumberDroppedFrames() override;
// Return the number of spatial resizes.
virtual int NumberSpatialResizes() OVERRIDE;
int NumberSpatialResizes() override;
webrtc::VideoEncoder* encoder_;
webrtc::VideoDecoder* decoder_;
@ -225,10 +225,10 @@ class VideoProcessorImpl : public VideoProcessor {
public:
explicit VideoProcessorEncodeCompleteCallback(VideoProcessorImpl* vp)
: video_processor_(vp) {}
virtual int32_t Encoded(
int32_t Encoded(
const webrtc::EncodedImage& encoded_image,
const webrtc::CodecSpecificInfo* codec_specific_info,
const webrtc::RTPFragmentationHeader* fragmentation) OVERRIDE;
const webrtc::RTPFragmentationHeader* fragmentation) override;
private:
VideoProcessorImpl* video_processor_;
@ -241,7 +241,7 @@ class VideoProcessorImpl : public VideoProcessor {
explicit VideoProcessorDecodeCompleteCallback(VideoProcessorImpl* vp)
: video_processor_(vp) {
}
virtual int32_t Decoded(webrtc::I420VideoFrame& image) OVERRIDE;
int32_t Decoded(webrtc::I420VideoFrame& image) override;
private:
VideoProcessorImpl* video_processor_;

2
webrtc/modules/video_coding/codecs/vp8/screenshare_layers_unittest.cc
View File

@ -46,7 +46,7 @@ class ScreenshareLayersFT : public ScreenshareLayers {
virtual ~ScreenshareLayersFT() {}
protected:
virtual bool TargetBitrateExperimentEnabled() OVERRIDE { return true; }
bool TargetBitrateExperimentEnabled() override { return true; }
};
class ScreenshareLayerTest : public ::testing::Test {

29
webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h
View File

@ -37,24 +37,21 @@ class SimulcastEncoderAdapter : public VP8Encoder,
virtual ~SimulcastEncoderAdapter();
// Implements VideoEncoder
virtual int Release() OVERRIDE;
virtual int InitEncode(const VideoCodec* inst,
int number_of_cores,
size_t max_payload_size) OVERRIDE;
virtual int Encode(const I420VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) OVERRIDE;
virtual int RegisterEncodeCompleteCallback(
EncodedImageCallback* callback) OVERRIDE;
virtual int SetChannelParameters(uint32_t packet_loss, int64_t rtt) OVERRIDE;
virtual int SetRates(uint32_t new_bitrate_kbit,
uint32_t new_framerate) OVERRIDE;
int Release() override;
int InitEncode(const VideoCodec* inst,
int number_of_cores,
size_t max_payload_size) override;
int Encode(const I420VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) override;
int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
int SetChannelParameters(uint32_t packet_loss, int64_t rtt) override;
int SetRates(uint32_t new_bitrate_kbit, uint32_t new_framerate) override;
// Implements EncodedImageCallback
virtual int32_t Encoded(
const EncodedImage& encodedImage,
const CodecSpecificInfo* codecSpecificInfo = NULL,
const RTPFragmentationHeader* fragmentation = NULL) OVERRIDE;
int32_t Encoded(const EncodedImage& encodedImage,
const CodecSpecificInfo* codecSpecificInfo = NULL,
const RTPFragmentationHeader* fragmentation = NULL) override;
private:
struct StreamInfo {

6
webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc
View File

@ -145,15 +145,13 @@ class MockVideoEncoder : public VideoEncoder {
class MockVideoEncoderFactory : public VideoEncoderFactory {
public:
virtual VideoEncoder* Create() OVERRIDE {
VideoEncoder* Create() override {
MockVideoEncoder* encoder = new MockVideoEncoder();
encoders_.push_back(encoder);
return encoder;
}
virtual void Destroy(VideoEncoder* encoder) OVERRIDE {
delete encoder;
}
void Destroy(VideoEncoder* encoder) override { delete encoder; }
virtual ~MockVideoEncoderFactory() {}

24
webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h
View File

@ -186,28 +186,26 @@ class SkipEncodingUnusedStreamsTest {
return layers_->EncodeFlags(timestamp);
}
virtual bool ConfigureBitrates(int bitrate_kbit,
int max_bitrate_kbit,
int framerate,
vpx_codec_enc_cfg_t* cfg) OVERRIDE {
bool ConfigureBitrates(int bitrate_kbit,
int max_bitrate_kbit,
int framerate,
vpx_codec_enc_cfg_t* cfg) override {
configured_bitrate_ = bitrate_kbit;
return layers_->ConfigureBitrates(
bitrate_kbit, max_bitrate_kbit, framerate, cfg);
}
virtual void PopulateCodecSpecific(bool base_layer_sync,
CodecSpecificInfoVP8* vp8_info,
uint32_t timestamp) OVERRIDE {
void PopulateCodecSpecific(bool base_layer_sync,
CodecSpecificInfoVP8* vp8_info,
uint32_t timestamp) override {
layers_->PopulateCodecSpecific(base_layer_sync, vp8_info, timestamp);
}
virtual void FrameEncoded(unsigned int size, uint32_t timestamp) OVERRIDE {
void FrameEncoded(unsigned int size, uint32_t timestamp) override {
layers_->FrameEncoded(size, timestamp);
}
virtual int CurrentLayerId() const OVERRIDE {
return layers_->CurrentLayerId();
}
int CurrentLayerId() const override { return layers_->CurrentLayerId(); }
int configured_bitrate_;
TemporalLayers* layers_;
@ -216,8 +214,8 @@ class SkipEncodingUnusedStreamsTest {
class SpyingTemporalLayersFactory : public TemporalLayers::Factory {
public:
virtual ~SpyingTemporalLayersFactory() {}
virtual TemporalLayers* Create(int temporal_layers,
uint8_t initial_tl0_pic_idx) const OVERRIDE {
TemporalLayers* Create(int temporal_layers,
uint8_t initial_tl0_pic_idx) const override {
SpyingTemporalLayers* layers =
new SpyingTemporalLayers(TemporalLayers::Factory::Create(
temporal_layers, initial_tl0_pic_idx));

8
webrtc/modules/video_coding/codecs/vp8/vp8_factory.cc
View File

@ -19,13 +19,9 @@ bool VP8EncoderFactoryConfig::use_simulcast_adapter_ = false;
class VP8EncoderImplFactory : public VideoEncoderFactory {
public:
virtual VideoEncoder* Create() OVERRIDE {
return new VP8EncoderImpl();
}
VideoEncoder* Create() override { return new VP8EncoderImpl(); }
virtual void Destroy(VideoEncoder* encoder) OVERRIDE {
delete encoder;
}
void Destroy(VideoEncoder* encoder) override { delete encoder; }
virtual ~VP8EncoderImplFactory() {}
};

40
webrtc/modules/video_coding/codecs/vp9/vp9_impl.h
View File

@ -25,22 +25,21 @@ class VP9EncoderImpl : public VP9Encoder {
virtual ~VP9EncoderImpl();
virtual int Release() OVERRIDE;
int Release() override;
virtual int InitEncode(const VideoCodec* codec_settings,
int number_of_cores,
size_t max_payload_size) OVERRIDE;
int InitEncode(const VideoCodec* codec_settings,
int number_of_cores,
size_t max_payload_size) override;
virtual int Encode(const I420VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) OVERRIDE;
int Encode(const I420VideoFrame& input_image,
const CodecSpecificInfo* codec_specific_info,
const std::vector<VideoFrameType>* frame_types) override;
virtual int RegisterEncodeCompleteCallback(EncodedImageCallback* callback)
OVERRIDE;
int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
virtual int SetChannelParameters(uint32_t packet_loss, int64_t rtt) OVERRIDE;
int SetChannelParameters(uint32_t packet_loss, int64_t rtt) override;
virtual int SetRates(uint32_t new_bitrate_kbit, uint32_t frame_rate) OVERRIDE;
int SetRates(uint32_t new_bitrate_kbit, uint32_t frame_rate) override;
private:
// Determine number of encoder threads to use.
@ -83,20 +82,19 @@ class VP9DecoderImpl : public VP9Decoder {
virtual ~VP9DecoderImpl();
virtual int InitDecode(const VideoCodec* inst, int number_of_cores) OVERRIDE;
int InitDecode(const VideoCodec* inst, int number_of_cores) override;
virtual int Decode(const EncodedImage& input_image,
bool missing_frames,
const RTPFragmentationHeader* fragmentation,
const CodecSpecificInfo* codec_specific_info,
int64_t /*render_time_ms*/) OVERRIDE;
int Decode(const EncodedImage& input_image,
bool missing_frames,
const RTPFragmentationHeader* fragmentation,
const CodecSpecificInfo* codec_specific_info,
int64_t /*render_time_ms*/) override;
virtual int RegisterDecodeCompleteCallback(DecodedImageCallback* callback)
OVERRIDE;
int RegisterDecodeCompleteCallback(DecodedImageCallback* callback) override;
virtual int Release() OVERRIDE;
int Release() override;
virtual int Reset() OVERRIDE;
int Reset() override;
private:
int ReturnFrame(const vpx_image_t* img, uint32_t timeStamp);

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

@ -88,7 +88,7 @@ class VideoCodingModuleImpl : public VideoCodingModule {
own_event_factory_.reset();
}
virtual int64_t TimeUntilNextProcess() OVERRIDE {
int64_t TimeUntilNextProcess() override {
int64_t sender_time = sender_->TimeUntilNextProcess();
int64_t receiver_time = receiver_->TimeUntilNextProcess();
assert(sender_time >= 0);
@ -96,7 +96,7 @@ class VideoCodingModuleImpl : public VideoCodingModule {
return VCM_MIN(sender_time, receiver_time);
}
virtual int32_t Process() OVERRIDE {
int32_t Process() override {
int32_t sender_return = sender_->Process();
int32_t receiver_return = receiver_->Process();
if (sender_return != VCM_OK)
@ -104,78 +104,75 @@ class VideoCodingModuleImpl : public VideoCodingModule {
return receiver_return;
}
virtual int32_t InitializeSender() OVERRIDE {
return sender_->InitializeSender();
}
int32_t InitializeSender() override { return sender_->InitializeSender(); }
virtual int32_t RegisterSendCodec(const VideoCodec* sendCodec,
uint32_t numberOfCores,
uint32_t maxPayloadSize) OVERRIDE {
int32_t RegisterSendCodec(const VideoCodec* sendCodec,
uint32_t numberOfCores,
uint32_t maxPayloadSize) override {
return sender_->RegisterSendCodec(sendCodec, numberOfCores, maxPayloadSize);
}
virtual const VideoCodec& GetSendCodec() const OVERRIDE {
const VideoCodec& GetSendCodec() const override {
return sender_->GetSendCodec();
}
// DEPRECATED.
virtual int32_t SendCodec(VideoCodec* currentSendCodec) const OVERRIDE {
int32_t SendCodec(VideoCodec* currentSendCodec) const override {
return sender_->SendCodecBlocking(currentSendCodec);
}
// DEPRECATED.
virtual VideoCodecType SendCodec() const OVERRIDE {
VideoCodecType SendCodec() const override {
return sender_->SendCodecBlocking();
}
virtual int32_t RegisterExternalEncoder(VideoEncoder* externalEncoder,
uint8_t payloadType,
bool internalSource) OVERRIDE {
int32_t RegisterExternalEncoder(VideoEncoder* externalEncoder,
uint8_t payloadType,
bool internalSource) override {
return sender_->RegisterExternalEncoder(
externalEncoder, payloadType, internalSource);
}
virtual int32_t CodecConfigParameters(uint8_t* buffer,
int32_t size) OVERRIDE {
int32_t CodecConfigParameters(uint8_t* buffer, int32_t size) override {
return sender_->CodecConfigParameters(buffer, size);
}
virtual int Bitrate(unsigned int* bitrate) const OVERRIDE {
int Bitrate(unsigned int* bitrate) const override {
return sender_->Bitrate(bitrate);
}
virtual int FrameRate(unsigned int* framerate) const OVERRIDE {
int FrameRate(unsigned int* framerate) const override {
return sender_->FrameRate(framerate);
}
virtual int32_t SetChannelParameters(uint32_t target_bitrate, // bits/s.
uint8_t lossRate,
int64_t rtt) OVERRIDE {
int32_t SetChannelParameters(uint32_t target_bitrate, // bits/s.
uint8_t lossRate,
int64_t rtt) override {
return sender_->SetChannelParameters(target_bitrate, lossRate, rtt);
}
virtual int32_t RegisterTransportCallback(
VCMPacketizationCallback* transport) OVERRIDE {
int32_t RegisterTransportCallback(
VCMPacketizationCallback* transport) override {
return sender_->RegisterTransportCallback(transport);
}
virtual int32_t RegisterSendStatisticsCallback(
VCMSendStatisticsCallback* sendStats) OVERRIDE {
int32_t RegisterSendStatisticsCallback(
VCMSendStatisticsCallback* sendStats) override {
return sender_->RegisterSendStatisticsCallback(sendStats);
}
virtual int32_t RegisterVideoQMCallback(
VCMQMSettingsCallback* videoQMSettings) OVERRIDE {
int32_t RegisterVideoQMCallback(
VCMQMSettingsCallback* videoQMSettings) override {
return sender_->RegisterVideoQMCallback(videoQMSettings);
}
virtual int32_t RegisterProtectionCallback(
VCMProtectionCallback* protection) OVERRIDE {
int32_t RegisterProtectionCallback(
VCMProtectionCallback* protection) override {
return sender_->RegisterProtectionCallback(protection);
}
virtual int32_t SetVideoProtection(VCMVideoProtection videoProtection,
bool enable) OVERRIDE {
int32_t SetVideoProtection(VCMVideoProtection videoProtection,
bool enable) override {
int32_t sender_return =
sender_->SetVideoProtection(videoProtection, enable);
int32_t receiver_return =
@ -185,172 +182,168 @@ class VideoCodingModuleImpl : public VideoCodingModule {
return sender_return;
}
virtual int32_t AddVideoFrame(
const I420VideoFrame& videoFrame,
const VideoContentMetrics* contentMetrics,
const CodecSpecificInfo* codecSpecificInfo) OVERRIDE {
int32_t AddVideoFrame(const I420VideoFrame& videoFrame,
const VideoContentMetrics* contentMetrics,
const CodecSpecificInfo* codecSpecificInfo) override {
return sender_->AddVideoFrame(
videoFrame, contentMetrics, codecSpecificInfo);
}
virtual int32_t IntraFrameRequest(int stream_index) OVERRIDE {
int32_t IntraFrameRequest(int stream_index) override {
return sender_->IntraFrameRequest(stream_index);
}
virtual int32_t EnableFrameDropper(bool enable) OVERRIDE {
int32_t EnableFrameDropper(bool enable) override {
return sender_->EnableFrameDropper(enable);
}
virtual int32_t SentFrameCount(VCMFrameCount& frameCount) const OVERRIDE {
int32_t SentFrameCount(VCMFrameCount& frameCount) const override {
return sender_->SentFrameCount(&frameCount);
}
virtual int SetSenderNackMode(SenderNackMode mode) OVERRIDE {
int SetSenderNackMode(SenderNackMode mode) override {
return sender_->SetSenderNackMode(mode);
}
virtual int SetSenderReferenceSelection(bool enable) OVERRIDE {
int SetSenderReferenceSelection(bool enable) override {
return sender_->SetSenderReferenceSelection(enable);
}
virtual int SetSenderFEC(bool enable) OVERRIDE {
int SetSenderFEC(bool enable) override {
return sender_->SetSenderFEC(enable);
}
virtual int SetSenderKeyFramePeriod(int periodMs) OVERRIDE {
int SetSenderKeyFramePeriod(int periodMs) override {
return sender_->SetSenderKeyFramePeriod(periodMs);
}
virtual int StartDebugRecording(const char* file_name_utf8) OVERRIDE {
int StartDebugRecording(const char* file_name_utf8) override {
return sender_->StartDebugRecording(file_name_utf8);
}
virtual int StopDebugRecording() OVERRIDE {
int StopDebugRecording() override {
sender_->StopDebugRecording();
return VCM_OK;
}
virtual void SuspendBelowMinBitrate() OVERRIDE {
void SuspendBelowMinBitrate() override {
return sender_->SuspendBelowMinBitrate();
}
virtual bool VideoSuspended() const OVERRIDE {
return sender_->VideoSuspended();
}
bool VideoSuspended() const override { return sender_->VideoSuspended(); }
virtual int32_t InitializeReceiver() OVERRIDE {
int32_t InitializeReceiver() override {
return receiver_->InitializeReceiver();
}
virtual int32_t RegisterReceiveCodec(const VideoCodec* receiveCodec,
int32_t numberOfCores,
bool requireKeyFrame) OVERRIDE {
int32_t RegisterReceiveCodec(const VideoCodec* receiveCodec,
int32_t numberOfCores,
bool requireKeyFrame) override {
return receiver_->RegisterReceiveCodec(
receiveCodec, numberOfCores, requireKeyFrame);
}
virtual int32_t RegisterExternalDecoder(VideoDecoder* externalDecoder,
uint8_t payloadType,
bool internalRenderTiming) OVERRIDE {
int32_t RegisterExternalDecoder(VideoDecoder* externalDecoder,
uint8_t payloadType,
bool internalRenderTiming) override {
return receiver_->RegisterExternalDecoder(
externalDecoder, payloadType, internalRenderTiming);
}
virtual int32_t RegisterReceiveCallback(
VCMReceiveCallback* receiveCallback) OVERRIDE {
int32_t RegisterReceiveCallback(
VCMReceiveCallback* receiveCallback) override {
return receiver_->RegisterReceiveCallback(receiveCallback);
}
virtual int32_t RegisterReceiveStatisticsCallback(
VCMReceiveStatisticsCallback* receiveStats) OVERRIDE {
int32_t RegisterReceiveStatisticsCallback(
VCMReceiveStatisticsCallback* receiveStats) override {
return receiver_->RegisterReceiveStatisticsCallback(receiveStats);
}
virtual int32_t RegisterDecoderTimingCallback(
VCMDecoderTimingCallback* decoderTiming) OVERRIDE {
int32_t RegisterDecoderTimingCallback(
VCMDecoderTimingCallback* decoderTiming) override {
return receiver_->RegisterDecoderTimingCallback(decoderTiming);
}
virtual int32_t RegisterFrameTypeCallback(
VCMFrameTypeCallback* frameTypeCallback) OVERRIDE {
int32_t RegisterFrameTypeCallback(
VCMFrameTypeCallback* frameTypeCallback) override {
return receiver_->RegisterFrameTypeCallback(frameTypeCallback);
}
virtual int32_t RegisterPacketRequestCallback(
VCMPacketRequestCallback* callback) OVERRIDE {
int32_t RegisterPacketRequestCallback(
VCMPacketRequestCallback* callback) override {
return receiver_->RegisterPacketRequestCallback(callback);
}
virtual int RegisterRenderBufferSizeCallback(
VCMRenderBufferSizeCallback* callback) OVERRIDE {
int RegisterRenderBufferSizeCallback(
VCMRenderBufferSizeCallback* callback) override {
return receiver_->RegisterRenderBufferSizeCallback(callback);
}
virtual int32_t Decode(uint16_t maxWaitTimeMs) OVERRIDE {
int32_t Decode(uint16_t maxWaitTimeMs) override {
return receiver_->Decode(maxWaitTimeMs);
}
virtual int32_t ResetDecoder() OVERRIDE { return receiver_->ResetDecoder(); }
int32_t ResetDecoder() override { return receiver_->ResetDecoder(); }
virtual int32_t ReceiveCodec(VideoCodec* currentReceiveCodec) const OVERRIDE {
int32_t ReceiveCodec(VideoCodec* currentReceiveCodec) const override {
return receiver_->ReceiveCodec(currentReceiveCodec);
}
virtual VideoCodecType ReceiveCodec() const OVERRIDE {
VideoCodecType ReceiveCodec() const override {
return receiver_->ReceiveCodec();
}
virtual int32_t IncomingPacket(const uint8_t* incomingPayload,
size_t payloadLength,
const WebRtcRTPHeader& rtpInfo) OVERRIDE {
int32_t IncomingPacket(const uint8_t* incomingPayload,
size_t payloadLength,
const WebRtcRTPHeader& rtpInfo) override {
return receiver_->IncomingPacket(incomingPayload, payloadLength, rtpInfo);
}
virtual int32_t SetMinimumPlayoutDelay(uint32_t minPlayoutDelayMs) OVERRIDE {
int32_t SetMinimumPlayoutDelay(uint32_t minPlayoutDelayMs) override {
return receiver_->SetMinimumPlayoutDelay(minPlayoutDelayMs);
}
virtual int32_t SetRenderDelay(uint32_t timeMS) OVERRIDE {
int32_t SetRenderDelay(uint32_t timeMS) override {
return receiver_->SetRenderDelay(timeMS);
}
virtual int32_t Delay() const OVERRIDE { return receiver_->Delay(); }
int32_t Delay() const override { return receiver_->Delay(); }
virtual uint32_t DiscardedPackets() const OVERRIDE {
uint32_t DiscardedPackets() const override {
return receiver_->DiscardedPackets();
}
virtual int SetReceiverRobustnessMode(ReceiverRobustness robustnessMode,
VCMDecodeErrorMode errorMode) OVERRIDE {
int SetReceiverRobustnessMode(ReceiverRobustness robustnessMode,
VCMDecodeErrorMode errorMode) override {
return receiver_->SetReceiverRobustnessMode(robustnessMode, errorMode);
}
virtual void SetNackSettings(size_t max_nack_list_size,
int max_packet_age_to_nack,
int max_incomplete_time_ms) OVERRIDE {
void SetNackSettings(size_t max_nack_list_size,
int max_packet_age_to_nack,
int max_incomplete_time_ms) override {
return receiver_->SetNackSettings(
max_nack_list_size, max_packet_age_to_nack, max_incomplete_time_ms);
}
void SetDecodeErrorMode(VCMDecodeErrorMode decode_error_mode) OVERRIDE {
void SetDecodeErrorMode(VCMDecodeErrorMode decode_error_mode) override {
return receiver_->SetDecodeErrorMode(decode_error_mode);
}
virtual int SetMinReceiverDelay(int desired_delay_ms) OVERRIDE {
int SetMinReceiverDelay(int desired_delay_ms) override {
return receiver_->SetMinReceiverDelay(desired_delay_ms);
}
virtual int32_t SetReceiveChannelParameters(int64_t rtt) OVERRIDE {
int32_t SetReceiveChannelParameters(int64_t rtt) override {
return receiver_->SetReceiveChannelParameters(rtt);
}
virtual void RegisterPreDecodeImageCallback(
EncodedImageCallback* observer) OVERRIDE {
void RegisterPreDecodeImageCallback(EncodedImageCallback* observer) override {
receiver_->RegisterPreDecodeImageCallback(observer);
}
virtual void RegisterPostEncodeImageCallback(
EncodedImageCallback* observer) OVERRIDE {
void RegisterPostEncodeImageCallback(
EncodedImageCallback* observer) override {
post_encode_callback_.Register(observer);
}

18
webrtc/modules/video_coding/main/source/video_sender_unittest.cc
View File

@ -70,7 +70,7 @@ MATCHER_P(MatchesVp8StreamInfo, expected, "") {
class EmptyFrameGenerator : public FrameGenerator {
public:
virtual I420VideoFrame* NextFrame() OVERRIDE {
I420VideoFrame* NextFrame() override {
frame_.reset(new I420VideoFrame());
return frame_.get();
}
@ -86,10 +86,10 @@ class PacketizationCallback : public VCMPacketizationCallback {
virtual ~PacketizationCallback() {}
virtual int32_t SendData(uint8_t payload_type,
const EncodedImage& encoded_image,
const RTPFragmentationHeader& fragmentation_header,
const RTPVideoHeader* rtp_video_header) OVERRIDE {
int32_t SendData(uint8_t payload_type,
const EncodedImage& encoded_image,
const RTPFragmentationHeader& fragmentation_header,
const RTPVideoHeader* rtp_video_header) override {
assert(rtp_video_header);
frame_data_.push_back(FrameData(encoded_image._length, *rtp_video_header));
return 0;
@ -171,7 +171,7 @@ class TestVideoSender : public ::testing::Test {
// a special case (e.g. frame rate in media optimization).
TestVideoSender() : clock_(1000), packetization_callback_(&clock_) {}
virtual void SetUp() OVERRIDE {
void SetUp() override {
sender_.reset(new VideoSender(&clock_, &post_encode_callback_, nullptr));
EXPECT_EQ(0, sender_->InitializeSender());
EXPECT_EQ(0, sender_->RegisterTransportCallback(&packetization_callback_));
@ -197,7 +197,7 @@ class TestVideoSenderWithMockEncoder : public TestVideoSender {
static const int kNumberOfLayers = 3;
static const int kUnusedPayloadType = 10;
virtual void SetUp() OVERRIDE {
void SetUp() override {
TestVideoSender::SetUp();
generator_.reset(new EmptyFrameGenerator());
EXPECT_EQ(
@ -220,7 +220,7 @@ class TestVideoSenderWithMockEncoder : public TestVideoSender {
EXPECT_EQ(0, sender_->RegisterSendCodec(&settings_, 1, 1200));
}
virtual void TearDown() OVERRIDE { sender_.reset(); }
void TearDown() override { sender_.reset(); }
void ExpectIntraRequest(int stream) {
if (stream == -1) {
@ -313,7 +313,7 @@ class TestVideoSenderWithVp8 : public TestVideoSender {
TestVideoSenderWithVp8()
: codec_bitrate_kbps_(300), available_bitrate_kbps_(1000) {}
virtual void SetUp() OVERRIDE {
void SetUp() override {
TestVideoSender::SetUp();
const char* input_video = "foreman_cif";

15
webrtc/modules/video_coding/main/test/generic_codec_test.h
View File

@ -75,10 +75,8 @@ class RTPSendCallback_SizeTest : public webrtc::Transport
public:
// constructor input: (receive side) rtp module to send encoded data to
RTPSendCallback_SizeTest() : _maxPayloadSize(0), _payloadSizeSum(0), _nPackets(0) {}
virtual int SendPacket(int channel, const void *data, size_t len) OVERRIDE;
virtual int SendRTCPPacket(int channel,
const void *data,
size_t len) OVERRIDE {
int SendPacket(int channel, const void* data, size_t len) override;
int SendRTCPPacket(int channel, const void* data, size_t len) override {
return 0;
}
void SetMaxPayloadSize(size_t maxPayloadSize);
@ -94,11 +92,10 @@ class VCMEncComplete_KeyReqTest : public webrtc::VCMPacketizationCallback
{
public:
VCMEncComplete_KeyReqTest(webrtc::VideoCodingModule &vcm) : _vcm(vcm), _seqNo(0), _timeStamp(0) {}
virtual int32_t SendData(
uint8_t payloadType,
const webrtc::EncodedImage& encoded_image,
const webrtc::RTPFragmentationHeader& fragmentationHeader,
const webrtc::RTPVideoHeader* videoHdr) OVERRIDE;
int32_t SendData(uint8_t payloadType,
const webrtc::EncodedImage& encoded_image,
const webrtc::RTPFragmentationHeader& fragmentationHeader,
const webrtc::RTPVideoHeader* videoHdr) override;
private:
webrtc::VideoCodingModule& _vcm;

2
webrtc/modules/video_coding/main/test/mt_test_common.h
View File

@ -52,7 +52,7 @@ class TransportCallback:public RTPSendCompleteCallback
// Add packets to list
// Incorporate network conditions - delay and packet loss
// Actual transmission will occur on a separate thread
virtual int SendPacket(int channel, const void *data, size_t len) OVERRIDE;
int SendPacket(int channel, const void* data, size_t len) override;
// Send to the receiver packets which are ready to be submitted
int TransportPackets();
};

11
webrtc/modules/video_coding/main/test/normal_test.h
View File

@ -32,11 +32,10 @@ class VCMNTEncodeCompleteCallback : public webrtc::VCMPacketizationCallback
void RegisterTransportCallback(webrtc::VCMPacketizationCallback* transport);
// process encoded data received from the encoder,
// pass stream to the VCMReceiver module
virtual int32_t SendData(
uint8_t payloadType,
const webrtc::EncodedImage& encoded_image,
const webrtc::RTPFragmentationHeader& fragmentationHeader,
const webrtc::RTPVideoHeader* videoHdr) OVERRIDE;
int32_t SendData(uint8_t payloadType,
const webrtc::EncodedImage& encoded_image,
const webrtc::RTPFragmentationHeader& fragmentationHeader,
const webrtc::RTPVideoHeader* videoHdr) override;
// Register existing VCM.
// Currently - encode and decode with the same vcm module.
@ -69,7 +68,7 @@ public:
void SetUserReceiveCallback(webrtc::VCMReceiveCallback* receiveCallback);
// will write decoded frame into file
virtual int32_t FrameToRender(webrtc::I420VideoFrame& videoFrame) OVERRIDE;
int32_t FrameToRender(webrtc::I420VideoFrame& videoFrame) override;
size_t DecodedBytes();
private:

4
webrtc/modules/video_coding/main/test/receiver_tests.h
View File

@ -27,10 +27,10 @@ class RtpDataCallback : public webrtc::NullRtpData {
RtpDataCallback(webrtc::VideoCodingModule* vcm) : vcm_(vcm) {}
virtual ~RtpDataCallback() {}
virtual int32_t OnReceivedPayloadData(
int32_t OnReceivedPayloadData(
const uint8_t* payload_data,
const size_t payload_size,
const webrtc::WebRtcRTPHeader* rtp_header) OVERRIDE {
const webrtc::WebRtcRTPHeader* rtp_header) override {
return vcm_->IncomingPacket(payload_data, payload_size, *rtp_header);
}

46
webrtc/modules/video_coding/main/test/test_callbacks.h
View File

@ -44,10 +44,10 @@ public:
void RegisterTransportCallback(VCMPacketizationCallback* transport);
// Process encoded data received from the encoder, pass stream to the
// VCMReceiver module
virtual int32_t SendData(uint8_t payloadType,
const EncodedImage& encoded_image,
const RTPFragmentationHeader& fragmentationHeader,
const RTPVideoHeader* videoHdr) OVERRIDE;
int32_t SendData(uint8_t payloadType,
const EncodedImage& encoded_image,
const RTPFragmentationHeader& fragmentationHeader,
const RTPVideoHeader* videoHdr) override;
// Register exisitng VCM. Currently - encode and decode under same module.
void RegisterReceiverVCM(VideoCodingModule *vcm) {_VCMReceiver = vcm;}
// Return size of last encoded frame data (all frames in the sequence)
@ -97,10 +97,10 @@ public:
virtual ~VCMRTPEncodeCompleteCallback() {}
// Process encoded data received from the encoder, pass stream to the
// RTP module
virtual int32_t SendData(uint8_t payloadType,
const EncodedImage& encoded_image,
const RTPFragmentationHeader& fragmentationHeader,
const RTPVideoHeader* videoHdr) OVERRIDE;
int32_t SendData(uint8_t payloadType,
const EncodedImage& encoded_image,
const RTPFragmentationHeader& fragmentationHeader,
const RTPVideoHeader* videoHdr) override;
// Return size of last encoded frame. Value good for one call
// (resets to zero after call to inform test of frame drop)
size_t EncodedBytes();
@ -136,7 +136,7 @@ public:
_decodedFile(decodedFile), _decodedBytes(0) {}
virtual ~VCMDecodeCompleteCallback() {}
// Write decoded frame into file
virtual int32_t FrameToRender(webrtc::I420VideoFrame& videoFrame) OVERRIDE;
int32_t FrameToRender(webrtc::I420VideoFrame& videoFrame) override;
size_t DecodedBytes();
private:
FILE* _decodedFile;
@ -157,11 +157,9 @@ public:
void SetRtpModule(RtpRtcp* rtp_module) { _rtp = rtp_module; }
// Send Packet to receive side RTP module
virtual int SendPacket(int channel, const void *data, size_t len) OVERRIDE;
int SendPacket(int channel, const void* data, size_t len) override;
// Send RTCP Packet to receive side RTP module
virtual int SendRTCPPacket(int channel,
const void *data,
size_t len) OVERRIDE;
int SendRTCPPacket(int channel, const void* data, size_t len) override;
// Set percentage of channel loss in the network
void SetLossPct(double lossPct);
// Set average size of burst loss
@ -203,8 +201,9 @@ class PacketRequester: public VCMPacketRequestCallback
public:
PacketRequester(RtpRtcp& rtp) :
_rtp(rtp) {}
virtual int32_t ResendPackets(const uint16_t* sequenceNumbers,
uint16_t length) OVERRIDE;
int32_t ResendPackets(const uint16_t* sequenceNumbers,
uint16_t length) override;
private:
webrtc::RtpRtcp& _rtp;
};
@ -213,7 +212,7 @@ private:
class KeyFrameReqTest: public VCMFrameTypeCallback
{
public:
virtual int32_t RequestKeyFrame() OVERRIDE;
int32_t RequestKeyFrame() override;
};
@ -222,8 +221,8 @@ class SendStatsTest: public webrtc::VCMSendStatisticsCallback
{
public:
SendStatsTest() : _framerate(15), _bitrate(500) {}
virtual int32_t SendStatistics(const uint32_t bitRate,
const uint32_t frameRate) OVERRIDE;
int32_t SendStatistics(const uint32_t bitRate,
const uint32_t frameRate) override;
void set_framerate(uint32_t frameRate) {_framerate = frameRate;}
void set_bitrate(uint32_t bitrate) {_bitrate = bitrate;}
private:
@ -239,12 +238,11 @@ public:
VideoProtectionCallback();
virtual ~VideoProtectionCallback();
void RegisterRtpModule(RtpRtcp* rtp) {_rtp = rtp;}
virtual int32_t ProtectionRequest(
const FecProtectionParams* delta_fec_params,
const FecProtectionParams* key_fec_params,
uint32_t* sent_video_rate_bps,
uint32_t* sent_nack_rate_bps,
uint32_t* sent_fec_rate_bps) OVERRIDE;
int32_t ProtectionRequest(const FecProtectionParams* delta_fec_params,
const FecProtectionParams* key_fec_params,
uint32_t* sent_video_rate_bps,
uint32_t* sent_nack_rate_bps,
uint32_t* sent_fec_rate_bps) override;
FecProtectionParams DeltaFecParameters() const;
FecProtectionParams KeyFecParameters() const;
private:

14
webrtc/modules/video_coding/main/test/vcm_payload_sink_factory.cc
View File

@ -48,22 +48,20 @@ class VcmPayloadSinkFactory::VcmPayloadSink
}
// PayloadSinkInterface
virtual int32_t OnReceivedPayloadData(
const uint8_t* payload_data,
const size_t payload_size,
const WebRtcRTPHeader* rtp_header) OVERRIDE {
int32_t OnReceivedPayloadData(const uint8_t* payload_data,
const size_t payload_size,
const WebRtcRTPHeader* rtp_header) override {
return vcm_->IncomingPacket(payload_data, payload_size, *rtp_header);
}
virtual bool OnRecoveredPacket(const uint8_t* packet,
size_t packet_length) OVERRIDE {
bool OnRecoveredPacket(const uint8_t* packet, size_t packet_length) override {
// We currently don't handle FEC.
return true;
}
// VCMPacketRequestCallback
virtual int32_t ResendPackets(const uint16_t* sequence_numbers,
uint16_t length) OVERRIDE {
int32_t ResendPackets(const uint16_t* sequence_numbers,
uint16_t length) override {
stream_->ResendPackets(sequence_numbers, length);
return 0;
}