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

4
webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc
View File

@ -46,7 +46,7 @@ class AudioEncoderCngTest : public ::testing::Test {
config_.payload_type = kCngPayloadType;
}
virtual void TearDown() OVERRIDE {
void TearDown() override {
EXPECT_CALL(*mock_vad_, Die()).Times(1);
cng_.reset();
// Don't expect the cng_ object to delete the AudioEncoder object. But it
@ -407,7 +407,7 @@ class AudioEncoderCngDeathTest : public AudioEncoderCngTest {
// Override AudioEncoderCngTest::TearDown, since that one expects a call to
// the destructor of |mock_vad_|. In this case, that object is already
// deleted.
virtual void TearDown() OVERRIDE {
void TearDown() override {
cng_.reset();
// Don't expect the cng_ object to delete the AudioEncoder object. But it
// will be deleted with the test fixture. This is why we explicitly delete

20
webrtc/modules/audio_coding/codecs/cng/include/audio_encoder_cng.h
View File

@ -44,22 +44,22 @@ class AudioEncoderCng final : public AudioEncoder {
explicit AudioEncoderCng(const Config& config);
virtual ~AudioEncoderCng();
~AudioEncoderCng() override;
virtual int SampleRateHz() const OVERRIDE;
virtual int NumChannels() const OVERRIDE;
int SampleRateHz() const override;
int NumChannels() const override;
int RtpTimestampRateHz() const override;
virtual int Num10MsFramesInNextPacket() const OVERRIDE;
virtual int Max10MsFramesInAPacket() const OVERRIDE;
int Num10MsFramesInNextPacket() const override;
int Max10MsFramesInAPacket() const override;
void SetTargetBitrate(int bits_per_second) override;
void SetProjectedPacketLossRate(double fraction) override;
protected:
virtual void EncodeInternal(uint32_t rtp_timestamp,
const int16_t* audio,
size_t max_encoded_bytes,
uint8_t* encoded,
EncodedInfo* info) OVERRIDE;
void EncodeInternal(uint32_t rtp_timestamp,
const int16_t* audio,
size_t max_encoded_bytes,
uint8_t* encoded,
EncodedInfo* info) override;
private:
// Deleter for use with scoped_ptr. E.g., use as

32
webrtc/modules/audio_coding/codecs/g711/include/audio_encoder_pcm.h
View File

@ -30,21 +30,21 @@ class AudioEncoderPcm : public AudioEncoder {
: frame_size_ms(20), num_channels(1), payload_type(pt) {}
};
virtual ~AudioEncoderPcm();
~AudioEncoderPcm() override;
virtual int SampleRateHz() const OVERRIDE;
virtual int NumChannels() const OVERRIDE;
virtual int Num10MsFramesInNextPacket() const OVERRIDE;
virtual int Max10MsFramesInAPacket() const OVERRIDE;
int SampleRateHz() const override;
int NumChannels() const override;
int Num10MsFramesInNextPacket() const override;
int Max10MsFramesInAPacket() const override;
protected:
AudioEncoderPcm(const Config& config, int sample_rate_hz);
virtual void EncodeInternal(uint32_t rtp_timestamp,
const int16_t* audio,
size_t max_encoded_bytes,
uint8_t* encoded,
EncodedInfo* info) OVERRIDE;
void EncodeInternal(uint32_t rtp_timestamp,
const int16_t* audio,
size_t max_encoded_bytes,
uint8_t* encoded,
EncodedInfo* info) override;
virtual int16_t EncodeCall(const int16_t* audio,
size_t input_len,
@ -70,9 +70,9 @@ class AudioEncoderPcmA : public AudioEncoderPcm {
: AudioEncoderPcm(config, kSampleRateHz) {}
protected:
virtual int16_t EncodeCall(const int16_t* audio,
size_t input_len,
uint8_t* encoded) OVERRIDE;
int16_t EncodeCall(const int16_t* audio,
size_t input_len,
uint8_t* encoded) override;
private:
static const int kSampleRateHz = 8000;
@ -88,9 +88,9 @@ class AudioEncoderPcmU : public AudioEncoderPcm {
: AudioEncoderPcm(config, kSampleRateHz) {}
protected:
virtual int16_t EncodeCall(const int16_t* audio,
size_t input_len,
uint8_t* encoded) OVERRIDE;
int16_t EncodeCall(const int16_t* audio,
size_t input_len,
uint8_t* encoded) override;
private:
static const int kSampleRateHz = 8000;

20
webrtc/modules/audio_coding/codecs/g722/include/audio_encoder_g722.h
View File

@ -28,20 +28,20 @@ class AudioEncoderG722 : public AudioEncoder {
};
explicit AudioEncoderG722(const Config& config);
virtual ~AudioEncoderG722();
~AudioEncoderG722() override;
virtual int SampleRateHz() const OVERRIDE;
int SampleRateHz() const override;
int RtpTimestampRateHz() const override;
virtual int NumChannels() const OVERRIDE;
virtual int Num10MsFramesInNextPacket() const OVERRIDE;
virtual int Max10MsFramesInAPacket() const OVERRIDE;
int NumChannels() const override;
int Num10MsFramesInNextPacket() const override;
int Max10MsFramesInAPacket() const override;
protected:
virtual void EncodeInternal(uint32_t rtp_timestamp,
const int16_t* audio,
size_t max_encoded_bytes,
uint8_t* encoded,
EncodedInfo* info) OVERRIDE;
void EncodeInternal(uint32_t rtp_timestamp,
const int16_t* audio,
size_t max_encoded_bytes,
uint8_t* encoded,
EncodedInfo* info) override;
private:
// The encoder state for one channel.

20
webrtc/modules/audio_coding/codecs/ilbc/interface/audio_encoder_ilbc.h
View File

@ -29,19 +29,19 @@ class AudioEncoderIlbc : public AudioEncoder {
};
explicit AudioEncoderIlbc(const Config& config);
virtual ~AudioEncoderIlbc();
~AudioEncoderIlbc() override;
virtual int SampleRateHz() const OVERRIDE;
virtual int NumChannels() const OVERRIDE;
virtual int Num10MsFramesInNextPacket() const OVERRIDE;
virtual int Max10MsFramesInAPacket() const OVERRIDE;
int SampleRateHz() const override;
int NumChannels() const override;
int Num10MsFramesInNextPacket() const override;
int Max10MsFramesInAPacket() const override;
protected:
virtual void EncodeInternal(uint32_t rtp_timestamp,
const int16_t* audio,
size_t max_encoded_bytes,
uint8_t* encoded,
EncodedInfo* info) OVERRIDE;
void EncodeInternal(uint32_t rtp_timestamp,
const int16_t* audio,
size_t max_encoded_bytes,
uint8_t* encoded,
EncodedInfo* info) override;
private:
static const int kMaxSamplesPerPacket = 480;

58
webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t.h
View File

@ -66,42 +66,42 @@ class AudioEncoderDecoderIsacT : public AudioEncoder, public AudioDecoder {
explicit AudioEncoderDecoderIsacT(const Config& config);
explicit AudioEncoderDecoderIsacT(const ConfigAdaptive& config);
virtual ~AudioEncoderDecoderIsacT() OVERRIDE;
~AudioEncoderDecoderIsacT() override;
// AudioEncoder public methods.
virtual int SampleRateHz() const OVERRIDE;
virtual int NumChannels() const OVERRIDE;
virtual int Num10MsFramesInNextPacket() const OVERRIDE;
virtual int Max10MsFramesInAPacket() const OVERRIDE;
int SampleRateHz() const override;
int NumChannels() const override;
int Num10MsFramesInNextPacket() const override;
int Max10MsFramesInAPacket() const override;
// AudioDecoder methods.
virtual int Decode(const uint8_t* encoded,
size_t encoded_len,
int sample_rate_hz,
int16_t* decoded,
SpeechType* speech_type) OVERRIDE;
virtual int DecodeRedundant(const uint8_t* encoded,
size_t encoded_len,
int sample_rate_hz,
int16_t* decoded,
SpeechType* speech_type) OVERRIDE;
virtual bool HasDecodePlc() const OVERRIDE;
virtual int DecodePlc(int num_frames, int16_t* decoded) OVERRIDE;
virtual int Init() OVERRIDE;
virtual int IncomingPacket(const uint8_t* payload,
size_t payload_len,
uint16_t rtp_sequence_number,
uint32_t rtp_timestamp,
uint32_t arrival_timestamp) OVERRIDE;
virtual int ErrorCode() OVERRIDE;
int Decode(const uint8_t* encoded,
size_t encoded_len,
int sample_rate_hz,
int16_t* decoded,
SpeechType* speech_type) override;
int DecodeRedundant(const uint8_t* encoded,
size_t encoded_len,
int sample_rate_hz,
int16_t* decoded,
SpeechType* speech_type) override;
bool HasDecodePlc() const override;
int DecodePlc(int num_frames, int16_t* decoded) override;
int Init() override;
int IncomingPacket(const uint8_t* payload,
size_t payload_len,
uint16_t rtp_sequence_number,
uint32_t rtp_timestamp,
uint32_t arrival_timestamp) override;
int ErrorCode() override;
protected:
// AudioEncoder protected method.
virtual void EncodeInternal(uint32_t rtp_timestamp,
const int16_t* audio,
size_t max_encoded_bytes,
uint8_t* encoded,
EncodedInfo* info) OVERRIDE;
void EncodeInternal(uint32_t rtp_timestamp,
const int16_t* audio,
size_t max_encoded_bytes,
uint8_t* encoded,
EncodedInfo* info) override;
private:
// This value is taken from STREAM_SIZE_MAX_60 for iSAC float (60 ms) and

4
webrtc/modules/audio_coding/codecs/isac/fix/test/isac_speed_test.cc
View File

@ -23,8 +23,8 @@ static const int kIsacOutputSamplingKhz = 16;
class IsacSpeedTest : public AudioCodecSpeedTest {
protected:
IsacSpeedTest();
virtual void SetUp() OVERRIDE;
virtual void TearDown() OVERRIDE;
void SetUp() override;
void TearDown() override;
virtual float EncodeABlock(int16_t* in_data, uint8_t* bit_stream,
int max_bytes, int* encoded_bytes);
virtual float DecodeABlock(const uint8_t* bit_stream, int encoded_bytes,

20
webrtc/modules/audio_coding/codecs/opus/interface/audio_encoder_opus.h
View File

@ -43,23 +43,23 @@ class AudioEncoderOpus final : public AudioEncoder {
};
explicit AudioEncoderOpus(const Config& config);
virtual ~AudioEncoderOpus() OVERRIDE;
~AudioEncoderOpus() override;
virtual int SampleRateHz() const OVERRIDE;
virtual int NumChannels() const OVERRIDE;
virtual int Num10MsFramesInNextPacket() const OVERRIDE;
virtual int Max10MsFramesInAPacket() const OVERRIDE;
int SampleRateHz() const override;
int NumChannels() const override;
int Num10MsFramesInNextPacket() const override;
int Max10MsFramesInAPacket() const override;
void SetTargetBitrate(int bits_per_second) override;
void SetProjectedPacketLossRate(double fraction) override;
double packet_loss_rate() const { return packet_loss_rate_; }
ApplicationMode application() const { return application_; }
protected:
virtual void EncodeInternal(uint32_t rtp_timestamp,
const int16_t* audio,
size_t max_encoded_bytes,
uint8_t* encoded,
EncodedInfo* info) OVERRIDE;
void EncodeInternal(uint32_t rtp_timestamp,
const int16_t* audio,
size_t max_encoded_bytes,
uint8_t* encoded,
EncodedInfo* info) override;
private:
const int num_10ms_frames_per_packet_;

4
webrtc/modules/audio_coding/codecs/opus/opus_speed_test.cc
View File

@ -21,8 +21,8 @@ static const int kOpusSamplingKhz = 48;
class OpusSpeedTest : public AudioCodecSpeedTest {
protected:
OpusSpeedTest();
virtual void SetUp() OVERRIDE;
virtual void TearDown() OVERRIDE;
void SetUp() override;
void TearDown() override;
virtual float EncodeABlock(int16_t* in_data, uint8_t* bit_stream,
int max_bytes, int* encoded_bytes);
virtual float DecodeABlock(const uint8_t* bit_stream, int encoded_bytes,

6
webrtc/modules/audio_coding/codecs/pcm16b/include/audio_encoder_pcm16b.h
View File

@ -28,9 +28,9 @@ class AudioEncoderPcm16B : public AudioEncoderPcm {
: AudioEncoderPcm(config, config.sample_rate_hz) {}
protected:
virtual int16_t EncodeCall(const int16_t* audio,
size_t input_len,
uint8_t* encoded) OVERRIDE;
int16_t EncodeCall(const int16_t* audio,
size_t input_len,
uint8_t* encoded) override;
};
} // namespace webrtc

20
webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.h
View File

@ -33,22 +33,22 @@ class AudioEncoderCopyRed : public AudioEncoder {
// Caller keeps ownership of the AudioEncoder object.
explicit AudioEncoderCopyRed(const Config& config);
virtual ~AudioEncoderCopyRed();
~AudioEncoderCopyRed() override;
virtual int SampleRateHz() const OVERRIDE;
int SampleRateHz() const override;
int RtpTimestampRateHz() const override;
virtual int NumChannels() const OVERRIDE;
virtual int Num10MsFramesInNextPacket() const OVERRIDE;
virtual int Max10MsFramesInAPacket() const OVERRIDE;
int NumChannels() const override;
int Num10MsFramesInNextPacket() const override;
int Max10MsFramesInAPacket() const override;
void SetTargetBitrate(int bits_per_second) override;
void SetProjectedPacketLossRate(double fraction) override;
protected:
virtual void EncodeInternal(uint32_t rtp_timestamp,
const int16_t* audio,
size_t max_encoded_bytes,
uint8_t* encoded,
EncodedInfo* info) OVERRIDE;
void EncodeInternal(uint32_t rtp_timestamp,
const int16_t* audio,
size_t max_encoded_bytes,
uint8_t* encoded,
EncodedInfo* info) override;
private:
AudioEncoder* speech_encoder_;

2
webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc
View File

@ -46,7 +46,7 @@ class AudioEncoderCopyRedTest : public ::testing::Test {
.WillRepeatedly(Return(sample_rate_hz_));
}
virtual void TearDown() OVERRIDE {
void TearDown() override {
red_.reset();
// Don't expect the red_ object to delete the AudioEncoder object. But it
// will be deleted with the test fixture. This is why we explicitly delete

2
webrtc/modules/audio_coding/main/acm2/acm_receive_test_oldapi.h
View File

@ -75,7 +75,7 @@ class AcmReceiveTestToggleOutputFreqOldApi : public AcmReceiveTestOldApi {
NumOutputChannels exptected_output_channels);
protected:
void AfterGetAudio() OVERRIDE;
void AfterGetAudio() override;
const int output_freq_hz_1_;
const int output_freq_hz_2_;

18
webrtc/modules/audio_coding/main/acm2/acm_receiver_unittest.cc
View File

@ -55,7 +55,7 @@ class AcmReceiverTest : public AudioPacketizationCallback,
~AcmReceiverTest() {}
virtual void SetUp() OVERRIDE {
void SetUp() override {
ASSERT_TRUE(receiver_.get() != NULL);
ASSERT_TRUE(acm_.get() != NULL);
for (int n = 0; n < ACMCodecDB::kNumCodecs; n++) {
@ -72,8 +72,7 @@ class AcmReceiverTest : public AudioPacketizationCallback,
rtp_header_.type.Audio.isCNG = false;
}
virtual void TearDown() OVERRIDE {
}
void TearDown() override {}
void InsertOnePacketOfSilence(int codec_id) {
CodecInst codec;
@ -115,13 +114,12 @@ class AcmReceiverTest : public AudioPacketizationCallback,
}
}
virtual int32_t SendData(
FrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,
size_t payload_len_bytes,
const RTPFragmentationHeader* fragmentation) OVERRIDE {
int32_t SendData(FrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,
size_t payload_len_bytes,
const RTPFragmentationHeader* fragmentation) override {
if (frame_type == kFrameEmpty)
return 0;

18
webrtc/modules/audio_coding/main/acm2/acm_receiver_unittest_oldapi.cc
View File

@ -54,7 +54,7 @@ class AcmReceiverTestOldApi : public AudioPacketizationCallback,
~AcmReceiverTestOldApi() {}
virtual void SetUp() OVERRIDE {
void SetUp() override {
ASSERT_TRUE(receiver_.get() != NULL);
ASSERT_TRUE(acm_.get() != NULL);
for (int n = 0; n < ACMCodecDB::kNumCodecs; n++) {
@ -75,8 +75,7 @@ class AcmReceiverTestOldApi : public AudioPacketizationCallback,
rtp_header_.type.Audio.isCNG = false;
}
virtual void TearDown() OVERRIDE {
}
void TearDown() override {}
void InsertOnePacketOfSilence(int codec_id) {
CodecInst codec;
@ -115,13 +114,12 @@ class AcmReceiverTestOldApi : public AudioPacketizationCallback,
}
}
virtual int SendData(
FrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,
size_t payload_len_bytes,
const RTPFragmentationHeader* fragmentation) OVERRIDE {
int SendData(FrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,
size_t payload_len_bytes,
const RTPFragmentationHeader* fragmentation) override {
if (frame_type == kFrameEmpty)
return 0;

15
webrtc/modules/audio_coding/main/acm2/acm_send_test.h
View File

@ -41,16 +41,15 @@ class AcmSendTest : public AudioPacketizationCallback, public PacketSource {
// Returns the next encoded packet. Returns NULL if the test duration was
// exceeded. Ownership of the packet is handed over to the caller.
// Inherited from PacketSource.
virtual Packet* NextPacket() OVERRIDE;
Packet* NextPacket() override;
// Inherited from AudioPacketizationCallback.
virtual int32_t SendData(
FrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,
size_t payload_len_bytes,
const RTPFragmentationHeader* fragmentation) OVERRIDE;
int32_t SendData(FrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,
size_t payload_len_bytes,
const RTPFragmentationHeader* fragmentation) override;
private:
static const int kBlockSizeMs = 10;

13
webrtc/modules/audio_coding/main/acm2/acm_send_test_oldapi.h
View File

@ -46,13 +46,12 @@ class AcmSendTestOldApi : public AudioPacketizationCallback,
Packet* NextPacket();
// Inherited from AudioPacketizationCallback.
virtual int32_t SendData(
FrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,
size_t payload_len_bytes,
const RTPFragmentationHeader* fragmentation) OVERRIDE;
int32_t SendData(FrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,
size_t payload_len_bytes,
const RTPFragmentationHeader* fragmentation) override;
AudioCodingModule* acm() { return acm_.get(); }

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

@ -43,59 +43,58 @@ class AudioCodingModuleImpl : public AudioCodingModule {
//
// Initialize send codec.
virtual int InitializeSender() OVERRIDE;
int InitializeSender() override;
// Reset send codec.
virtual int ResetEncoder() OVERRIDE;
int ResetEncoder() override;
// Can be called multiple times for Codec, CNG, RED.
virtual int RegisterSendCodec(const CodecInst& send_codec) OVERRIDE;
int RegisterSendCodec(const CodecInst& send_codec) override;
// Get current send codec.
virtual int SendCodec(CodecInst* current_codec) const OVERRIDE;
int SendCodec(CodecInst* current_codec) const override;
// Get current send frequency.
virtual int SendFrequency() const OVERRIDE;
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.
virtual int SendBitrate() const OVERRIDE;
int SendBitrate() const override;
// Set available bandwidth, inform the encoder about the
// estimated bandwidth received from the remote party.
virtual int SetReceivedEstimatedBandwidth(int bw) OVERRIDE;
int SetReceivedEstimatedBandwidth(int bw) override;
// Register a transport callback which will be
// called to deliver the encoded buffers.
virtual int RegisterTransportCallback(
AudioPacketizationCallback* transport) OVERRIDE;
int RegisterTransportCallback(AudioPacketizationCallback* transport) override;
// Add 10 ms of raw (PCM) audio data to the encoder.
virtual int Add10MsData(const AudioFrame& audio_frame) OVERRIDE;
int Add10MsData(const AudioFrame& audio_frame) override;
/////////////////////////////////////////
// (RED) Redundant Coding
//
// Configure RED status i.e. on/off.
virtual int SetREDStatus(bool enable_red) OVERRIDE;
int SetREDStatus(bool enable_red) override;
// Get RED status.
virtual bool REDStatus() const OVERRIDE;
bool REDStatus() const override;
/////////////////////////////////////////
// (FEC) Forward Error Correction (codec internal)
//
// Configure FEC status i.e. on/off.
virtual int SetCodecFEC(bool enabled_codec_fec) OVERRIDE;
int SetCodecFEC(bool enabled_codec_fec) override;
// Get FEC status.
virtual bool CodecFEC() const OVERRIDE;
bool CodecFEC() const override;
// Set target packet loss rate
virtual int SetPacketLossRate(int loss_rate) OVERRIDE;
int SetPacketLossRate(int loss_rate) override;
/////////////////////////////////////////
// (VAD) Voice Activity Detection
@ -103,98 +102,97 @@ class AudioCodingModuleImpl : public AudioCodingModule {
// (CNG) Comfort Noise Generation
//
virtual int SetVAD(bool enable_dtx = true,
bool enable_vad = false,
ACMVADMode mode = VADNormal) OVERRIDE;
int SetVAD(bool enable_dtx = true,
bool enable_vad = false,
ACMVADMode mode = VADNormal) override;
virtual int VAD(bool* dtx_enabled,
bool* vad_enabled,
ACMVADMode* mode) const OVERRIDE;
int VAD(bool* dtx_enabled,
bool* vad_enabled,
ACMVADMode* mode) const override;
virtual int RegisterVADCallback(ACMVADCallback* vad_callback) OVERRIDE;
int RegisterVADCallback(ACMVADCallback* vad_callback) override;
/////////////////////////////////////////
// Receiver
//
// Initialize receiver, resets codec database etc.
virtual int InitializeReceiver() OVERRIDE;
int InitializeReceiver() override;
// Reset the decoder state.
virtual int ResetDecoder() OVERRIDE;
int ResetDecoder() override;
// Get current receive frequency.
virtual int ReceiveFrequency() const OVERRIDE;
int ReceiveFrequency() const override;
// Get current playout frequency.
virtual int PlayoutFrequency() const OVERRIDE;
int PlayoutFrequency() const override;
// Register possible receive codecs, can be called multiple times,
// for codecs, CNG, DTMF, RED.
virtual int RegisterReceiveCodec(const CodecInst& receive_codec) OVERRIDE;
int RegisterReceiveCodec(const CodecInst& receive_codec) override;
// Get current received codec.
virtual int ReceiveCodec(CodecInst* current_codec) const OVERRIDE;
int ReceiveCodec(CodecInst* current_codec) const override;
// Incoming packet from network parsed and ready for decode.
virtual int IncomingPacket(const uint8_t* incoming_payload,
const size_t payload_length,
const WebRtcRTPHeader& rtp_info) OVERRIDE;
int IncomingPacket(const uint8_t* incoming_payload,
const size_t 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.
virtual int IncomingPayload(const uint8_t* incoming_payload,
const size_t payload_length,
uint8_t payload_type,
uint32_t timestamp) OVERRIDE;
int IncomingPayload(const uint8_t* incoming_payload,
const size_t payload_length,
uint8_t payload_type,
uint32_t timestamp) override;
// Minimum playout delay.
virtual int SetMinimumPlayoutDelay(int time_ms) OVERRIDE;
int SetMinimumPlayoutDelay(int time_ms) override;
// Maximum playout delay.
virtual int SetMaximumPlayoutDelay(int time_ms) OVERRIDE;
int SetMaximumPlayoutDelay(int time_ms) override;
// Smallest latency NetEq will maintain.
virtual int LeastRequiredDelayMs() const OVERRIDE;
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.
virtual int SetInitialPlayoutDelay(int delay_ms) OVERRIDE;
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.
virtual int SetDtmfPlayoutStatus(bool enable) OVERRIDE { return 0; }
int SetDtmfPlayoutStatus(bool enable) override { return 0; }
// Get Dtmf playout status.
virtual bool DtmfPlayoutStatus() const OVERRIDE { return true; }
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 .
virtual int DecoderEstimatedBandwidth() const OVERRIDE;
int DecoderEstimatedBandwidth() const override;
// Set playout mode voice, fax.
virtual int SetPlayoutMode(AudioPlayoutMode mode) OVERRIDE;
int SetPlayoutMode(AudioPlayoutMode mode) override;
// Get playout mode voice, fax.
virtual AudioPlayoutMode PlayoutMode() const OVERRIDE;
AudioPlayoutMode PlayoutMode() const override;
// Get playout timestamp.
virtual int PlayoutTimestamp(uint32_t* timestamp) OVERRIDE;
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.
virtual int PlayoutData10Ms(int desired_freq_hz,
AudioFrame* audio_frame) OVERRIDE;
int PlayoutData10Ms(int desired_freq_hz, AudioFrame* audio_frame) override;
/////////////////////////////////////////
// Statistics
//
virtual int GetNetworkStatistics(NetworkStatistics* statistics) OVERRIDE;
int GetNetworkStatistics(NetworkStatistics* statistics) override;
// GET RED payload for iSAC. The method id called when 'this' ACM is
// the default ACM.
@ -204,40 +202,37 @@ class AudioCodingModuleImpl : public AudioCodingModule {
uint8_t* payload,
int16_t* length_bytes);
virtual int ReplaceInternalDTXWithWebRtc(bool use_webrtc_dtx) OVERRIDE;
int ReplaceInternalDTXWithWebRtc(bool use_webrtc_dtx) override;
virtual int IsInternalDTXReplacedWithWebRtc(bool* uses_webrtc_dtx) OVERRIDE;
int IsInternalDTXReplacedWithWebRtc(bool* uses_webrtc_dtx) override;
virtual int SetISACMaxRate(int max_bit_per_sec) OVERRIDE;
int SetISACMaxRate(int max_bit_per_sec) override;
virtual int SetISACMaxPayloadSize(int max_size_bytes) OVERRIDE;
int SetISACMaxPayloadSize(int max_size_bytes) override;
virtual int ConfigISACBandwidthEstimator(
int frame_size_ms,
int rate_bit_per_sec,
bool enforce_frame_size = false) OVERRIDE;
int ConfigISACBandwidthEstimator(int frame_size_ms,
int rate_bit_per_sec,
bool enforce_frame_size = false) override;
int SetOpusApplication(OpusApplicationMode application) override;
// If current send codec is Opus, informs it about the maximum playback rate
// the receiver will render.
virtual int SetOpusMaxPlaybackRate(int frequency_hz) OVERRIDE;
int SetOpusMaxPlaybackRate(int frequency_hz) override;
int EnableOpusDtx() override;
int DisableOpusDtx() override;
virtual int UnregisterReceiveCodec(uint8_t payload_type) OVERRIDE;
int UnregisterReceiveCodec(uint8_t payload_type) override;
virtual int EnableNack(size_t max_nack_list_size) OVERRIDE;
int EnableNack(size_t max_nack_list_size) override;
virtual void DisableNack() OVERRIDE;
void DisableNack() override;
virtual std::vector<uint16_t> GetNackList(
int64_t round_trip_time_ms) const OVERRIDE;
std::vector<uint16_t> GetNackList(int64_t round_trip_time_ms) const override;
virtual void GetDecodingCallStatistics(
AudioDecodingCallStats* stats) const OVERRIDE;
void GetDecodingCallStatistics(AudioDecodingCallStats* stats) const override;
private:
struct InputData {
@ -372,62 +367,57 @@ class AudioCodingImpl : public AudioCoding {
playout_frequency_hz_ = config.playout_frequency_hz;
}
virtual ~AudioCodingImpl() OVERRIDE {};
~AudioCodingImpl() override{};
virtual bool RegisterSendCodec(AudioEncoder* send_codec) OVERRIDE;
bool RegisterSendCodec(AudioEncoder* send_codec) override;
virtual bool RegisterSendCodec(int encoder_type,
uint8_t payload_type,
int frame_size_samples = 0) OVERRIDE;
bool RegisterSendCodec(int encoder_type,
uint8_t payload_type,
int frame_size_samples = 0) override;
virtual const AudioEncoder* GetSenderInfo() const OVERRIDE;
const AudioEncoder* GetSenderInfo() const override;
virtual const CodecInst* GetSenderCodecInst() OVERRIDE;
const CodecInst* GetSenderCodecInst() override;
virtual int Add10MsAudio(const AudioFrame& audio_frame) OVERRIDE;
int Add10MsAudio(const AudioFrame& audio_frame) override;
virtual const ReceiverInfo* GetReceiverInfo() const OVERRIDE;
const ReceiverInfo* GetReceiverInfo() const override;
virtual bool RegisterReceiveCodec(AudioDecoder* receive_codec) OVERRIDE;
bool RegisterReceiveCodec(AudioDecoder* receive_codec) override;
virtual bool RegisterReceiveCodec(int decoder_type,
uint8_t payload_type) OVERRIDE;
bool RegisterReceiveCodec(int decoder_type, uint8_t payload_type) override;
virtual bool InsertPacket(const uint8_t* incoming_payload,
size_t payload_len_bytes,
const WebRtcRTPHeader& rtp_info) OVERRIDE;
bool InsertPacket(const uint8_t* incoming_payload,
size_t payload_len_bytes,
const WebRtcRTPHeader& rtp_info) override;
virtual bool InsertPayload(const uint8_t* incoming_payload,
size_t payload_len_byte,
uint8_t payload_type,
uint32_t timestamp) OVERRIDE;
bool InsertPayload(const uint8_t* incoming_payload,
size_t payload_len_byte,
uint8_t payload_type,
uint32_t timestamp) override;
virtual bool SetMinimumPlayoutDelay(int time_ms) OVERRIDE;
bool SetMinimumPlayoutDelay(int time_ms) override;
virtual bool SetMaximumPlayoutDelay(int time_ms) OVERRIDE;
bool SetMaximumPlayoutDelay(int time_ms) override;
virtual int LeastRequiredDelayMs() const OVERRIDE;
int LeastRequiredDelayMs() const override;
virtual bool PlayoutTimestamp(uint32_t* timestamp) OVERRIDE;
bool PlayoutTimestamp(uint32_t* timestamp) override;
virtual bool Get10MsAudio(AudioFrame* audio_frame) OVERRIDE;
bool Get10MsAudio(AudioFrame* audio_frame) override;
virtual bool GetNetworkStatistics(
NetworkStatistics* network_statistics) OVERRIDE;
bool GetNetworkStatistics(NetworkStatistics* network_statistics) override;
virtual bool EnableNack(size_t max_nack_list_size) OVERRIDE;
bool EnableNack(size_t max_nack_list_size) override;
virtual void DisableNack() OVERRIDE;
void DisableNack() override;
virtual bool SetVad(bool enable_dtx,
bool enable_vad,
ACMVADMode vad_mode) OVERRIDE;
bool SetVad(bool enable_dtx, bool enable_vad, ACMVADMode vad_mode) override;
virtual std::vector<uint16_t> GetNackList(
int round_trip_time_ms) const OVERRIDE;
std::vector<uint16_t> GetNackList(int round_trip_time_ms) const override;
virtual void GetDecodingCallStatistics(
AudioDecodingCallStats* call_stats) const OVERRIDE;
void GetDecodingCallStatistics(
AudioDecodingCallStats* call_stats) const override;
private:
// Temporary method to be used during redesign phase.

33
webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest.cc
View File

@ -81,13 +81,12 @@ class PacketizationCallbackStub : public AudioPacketizationCallback {
: num_calls_(0),
crit_sect_(CriticalSectionWrapper::CreateCriticalSection()) {}
virtual int32_t SendData(
FrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,
size_t payload_len_bytes,
const RTPFragmentationHeader* fragmentation) OVERRIDE {
int32_t SendData(FrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,
size_t payload_len_bytes,
const RTPFragmentationHeader* fragmentation) override {
CriticalSectionScoped lock(crit_sect_.get());
++num_calls_;
last_payload_vec_.assign(payload_data, payload_data + payload_len_bytes);
@ -124,9 +123,9 @@ class AudioCodingModuleTest : public ::testing::Test {
~AudioCodingModuleTest() {}
void TearDown() OVERRIDE {}
void TearDown() override {}
void SetUp() OVERRIDE {
void SetUp() override {
rtp_utility_->Populate(&rtp_header_);
input_frame_.sample_rate_hz_ = kSampleRateHz;
@ -308,7 +307,7 @@ class AudioCodingModuleMtTest : public AudioCodingModuleTest {
config_.clock = fake_clock_.get();
}
virtual void SetUp() OVERRIDE {
void SetUp() override {
AudioCodingModuleTest::SetUp();
CreateAcm();
StartThreads();
@ -321,7 +320,7 @@ class AudioCodingModuleMtTest : public AudioCodingModuleTest {
ASSERT_TRUE(pull_audio_thread_->Start(thread_id));
}
virtual void TearDown() OVERRIDE {
void TearDown() override {
AudioCodingModuleTest::TearDown();
pull_audio_thread_->Stop();
send_thread_->Stop();
@ -436,7 +435,7 @@ class AcmIsacMtTest : public AudioCodingModuleMtTest {
~AcmIsacMtTest() {}
virtual void SetUp() OVERRIDE {
void SetUp() override {
AudioCodingModuleTest::SetUp();
CreateAcm();
@ -459,7 +458,7 @@ class AcmIsacMtTest : public AudioCodingModuleMtTest {
StartThreads();
}
virtual void RegisterCodec() OVERRIDE {
void RegisterCodec() override {
static_assert(kSampleRateHz == 16000, "test designed for iSAC 16 kHz");
// Register iSAC codec in ACM, effectively unregistering the PCM16B codec
@ -469,7 +468,7 @@ class AcmIsacMtTest : public AudioCodingModuleMtTest {
acm_->RegisterReceiveCodec(acm2::ACMCodecDB::kISAC, kPayloadType));
}
virtual void InsertPacket() OVERRIDE {
void InsertPacket() override {
int num_calls = packet_cb_.num_calls(); // Store locally for thread safety.
if (num_calls > last_packet_number_) {
// Get the new payload out from the callback handler.
@ -486,14 +485,14 @@ class AcmIsacMtTest : public AudioCodingModuleMtTest {
&last_payload_vec_[0], last_payload_vec_.size(), rtp_header_));
}
virtual void InsertAudio() OVERRIDE {
void InsertAudio() override {
memcpy(input_frame_.data_, audio_loop_.GetNextBlock(), kNumSamples10ms);
AudioCodingModuleTest::InsertAudio();
}
// This method is the same as AudioCodingModuleMtTest::TestDone(), but here
// it is using the constants defined in this class (i.e., shorter test run).
virtual bool TestDone() OVERRIDE {
bool TestDone() override {
if (packet_cb_.num_calls() > kNumPackets) {
CriticalSectionScoped lock(crit_sect_.get());
if (pull_audio_count_ > kNumPullCalls) {
@ -708,7 +707,7 @@ class AcmSenderBitExactness : public ::testing::Test,
// Returns a pointer to the next packet. Returns NULL if the source is
// depleted (i.e., the test duration is exceeded), or if an error occurred.
// Inherited from test::PacketSource.
virtual test::Packet* NextPacket() OVERRIDE {
test::Packet* NextPacket() override {
// Get the next packet from AcmSendTest. Ownership of |packet| is
// transferred to this method.
test::Packet* packet = send_test_->NextPacket();

17
webrtc/modules/audio_coding/main/acm2/audio_coding_module_unittest_oldapi.cc
View File

@ -86,13 +86,12 @@ class PacketizationCallbackStubOldApi : public AudioPacketizationCallback {
last_payload_type_(-1),
crit_sect_(CriticalSectionWrapper::CreateCriticalSection()) {}
virtual int32_t SendData(
FrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,
size_t payload_len_bytes,
const RTPFragmentationHeader* fragmentation) OVERRIDE {
int32_t SendData(FrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,
size_t payload_len_bytes,
const RTPFragmentationHeader* fragmentation) override {
CriticalSectionScoped lock(crit_sect_.get());
++num_calls_;
last_frame_type_ = frame_type;
@ -855,7 +854,7 @@ class AcmSenderBitExactnessOldApi : public ::testing::Test,
// Returns a pointer to the next packet. Returns NULL if the source is
// depleted (i.e., the test duration is exceeded), or if an error occurred.
// Inherited from test::PacketSource.
test::Packet* NextPacket() OVERRIDE {
test::Packet* NextPacket() override {
// Get the next packet from AcmSendTest. Ownership of |packet| is
// transferred to this method.
test::Packet* packet = send_test_->NextPacket();
@ -1185,7 +1184,7 @@ class AcmSwitchingOutputFrequencyOldApi : public ::testing::Test,
}
// Inherited from test::PacketSource.
test::Packet* NextPacket() OVERRIDE {
test::Packet* NextPacket() override {
// Check if it is time to terminate the test. The packet source is of type
// ConstantPcmPacketSource, which is infinite, so we must end the test
// "manually".

13
webrtc/modules/audio_coding/main/test/Channel.h
View File

@ -50,13 +50,12 @@ class Channel : public AudioPacketizationCallback {
Channel(int16_t chID = -1);
~Channel();
virtual int32_t SendData(
FrameType frameType,
uint8_t payloadType,
uint32_t timeStamp,
const uint8_t* payloadData,
size_t payloadSize,
const RTPFragmentationHeader* fragmentation) OVERRIDE;
int32_t SendData(FrameType frameType,
uint8_t payloadType,
uint32_t timeStamp,
const uint8_t* payloadData,
size_t payloadSize,
const RTPFragmentationHeader* fragmentation) override;
void RegisterReceiverACM(AudioCodingModule *acm);

15
webrtc/modules/audio_coding/main/test/EncodeDecodeTest.h
View File

@ -29,13 +29,12 @@ class TestPacketization : public AudioPacketizationCallback {
public:
TestPacketization(RTPStream *rtpStream, uint16_t frequency);
~TestPacketization();
virtual int32_t SendData(
const FrameType frameType,
const uint8_t payloadType,
const uint32_t timeStamp,
const uint8_t* payloadData,
const size_t payloadSize,
const RTPFragmentationHeader* fragmentation) OVERRIDE;
int32_t SendData(const FrameType frameType,
const uint8_t payloadType,
const uint32_t timeStamp,
const uint8_t* payloadData,
const size_t payloadSize,
const RTPFragmentationHeader* fragmentation) override;
private:
static void MakeRTPheader(uint8_t* rtpHeader, uint8_t payloadType,
@ -103,7 +102,7 @@ class EncodeDecodeTest : public ACMTest {
public:
EncodeDecodeTest();
explicit EncodeDecodeTest(int testMode);
virtual void Perform() OVERRIDE;
void Perform() override;
uint16_t _playoutFreq;
uint8_t _testMode;

3
webrtc/modules/audio_coding/main/test/PacketLossTest.h
View File

@ -23,7 +23,8 @@ class ReceiverWithPacketLoss : public Receiver {
void Setup(AudioCodingModule *acm, RTPStream *rtpStream,
std::string out_file_name, int channels, int loss_rate,
int burst_length);
bool IncomingPacket() OVERRIDE;
bool IncomingPacket() override;
protected:
bool PacketLost();
int loss_rate_;

36
webrtc/modules/audio_coding/main/test/RTPFile.h
View File

@ -65,14 +65,19 @@ class RTPBuffer : public RTPStream {
~RTPBuffer();
virtual void Write(const uint8_t payloadType, const uint32_t timeStamp,
const int16_t seqNo, const uint8_t* payloadData,
const size_t payloadSize, uint32_t frequency) OVERRIDE;
void Write(const uint8_t payloadType,
const uint32_t timeStamp,
const int16_t seqNo,
const uint8_t* payloadData,
const size_t payloadSize,
uint32_t frequency) override;
virtual size_t Read(WebRtcRTPHeader* rtpInfo, uint8_t* payloadData,
size_t payloadSize, uint32_t* offset) OVERRIDE;
size_t Read(WebRtcRTPHeader* rtpInfo,
uint8_t* payloadData,
size_t payloadSize,
uint32_t* offset) override;
virtual bool EndOfFile() const OVERRIDE;
bool EndOfFile() const override;
private:
RWLockWrapper* _queueRWLock;
@ -97,16 +102,19 @@ class RTPFile : public RTPStream {
void ReadHeader();
virtual void Write(const uint8_t payloadType, const uint32_t timeStamp,
const int16_t seqNo, const uint8_t* payloadData,
const size_t payloadSize, uint32_t frequency) OVERRIDE;
void Write(const uint8_t payloadType,
const uint32_t timeStamp,
const int16_t seqNo,
const uint8_t* payloadData,
const size_t payloadSize,
uint32_t frequency) override;
virtual size_t Read(WebRtcRTPHeader* rtpInfo, uint8_t* payloadData,
size_t payloadSize, uint32_t* offset) OVERRIDE;
size_t Read(WebRtcRTPHeader* rtpInfo,
uint8_t* payloadData,
size_t payloadSize,
uint32_t* offset) override;
virtual bool EndOfFile() const OVERRIDE {
return _rtpEOF;
}
bool EndOfFile() const override { return _rtpEOF; }
private:
FILE* _rtpFile;

15
webrtc/modules/audio_coding/main/test/TestAllCodecs.h
View File

@ -28,13 +28,12 @@ class TestPack : public AudioPacketizationCallback {
void RegisterReceiverACM(AudioCodingModule* acm);
virtual int32_t SendData(
FrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,
size_t payload_size,
const RTPFragmentationHeader* fragmentation) OVERRIDE;
int32_t SendData(FrameType frame_type,
uint8_t payload_type,
uint32_t timestamp,
const uint8_t* payload_data,
size_t payload_size,
const RTPFragmentationHeader* fragmentation) override;
size_t payload_size();
uint32_t timestamp_diff();
@ -55,7 +54,7 @@ class TestAllCodecs : public ACMTest {
explicit TestAllCodecs(int test_mode);
~TestAllCodecs();
virtual void Perform() OVERRIDE;
void Perform() override;
private:
// The default value of '-1' indicates that the registration is based only on

16
webrtc/modules/audio_coding/main/test/TestStereo.h
View File

@ -35,13 +35,12 @@ class TestPackStereo : public AudioPacketizationCallback {
void RegisterReceiverACM(AudioCodingModule* acm);
virtual int32_t SendData(
const FrameType frame_type,
const uint8_t payload_type,
const uint32_t timestamp,
const uint8_t* payload_data,
const size_t payload_size,
const RTPFragmentationHeader* fragmentation) OVERRIDE;
int32_t SendData(const FrameType frame_type,
const uint8_t payload_type,
const uint32_t timestamp,
const uint8_t* payload_data,
const size_t payload_size,
const RTPFragmentationHeader* fragmentation) override;
uint16_t payload_size();
uint32_t timestamp_diff();
@ -66,7 +65,8 @@ class TestStereo : public ACMTest {
explicit TestStereo(int test_mode);
~TestStereo();
virtual void Perform() OVERRIDE;
void Perform() override;
private:
// The default value of '-1' indicates that the registration is based only on
// codec name and a sampling frequncy matching is not required. This is useful

16
webrtc/modules/audio_coding/neteq/accelerate.h
View File

@ -49,16 +49,18 @@ class Accelerate : public TimeStretch {
protected:
// Sets the parameters |best_correlation| and |peak_index| to suitable
// values when the signal contains no active speech.
virtual void SetParametersForPassiveSpeech(size_t len,
int16_t* best_correlation,
int* peak_index) const OVERRIDE;
void SetParametersForPassiveSpeech(size_t len,
int16_t* best_correlation,
int* peak_index) const override;
// Checks the criteria for performing the time-stretching operation and,
// if possible, performs the time-stretching.
virtual ReturnCodes CheckCriteriaAndStretch(
const int16_t* input, size_t input_length, size_t peak_index,
int16_t best_correlation, bool active_speech,
AudioMultiVector* output) const OVERRIDE;
ReturnCodes CheckCriteriaAndStretch(const int16_t* input,
size_t input_length,
size_t peak_index,
int16_t best_correlation,
bool active_speech,
AudioMultiVector* output) const override;
private:
DISALLOW_COPY_AND_ASSIGN(Accelerate);

2
webrtc/modules/audio_coding/neteq/audio_decoder_impl.h
View File

@ -233,7 +233,7 @@ class AudioDecoderCng : public AudioDecoder {
uint32_t rtp_timestamp,
uint32_t arrival_timestamp) { return -1; }
virtual CNG_dec_inst* CngDecoderInstance() OVERRIDE { return dec_state_; }
CNG_dec_inst* CngDecoderInstance() override { return dec_state_; }
private:
CNG_dec_inst* dec_state_;

14
webrtc/modules/audio_coding/neteq/decision_logic_fax.h
View File

@ -47,13 +47,13 @@ class DecisionLogicFax : public DecisionLogic {
// should be set to true. The output variable |reset_decoder| will be set to
// true if a reset is required; otherwise it is left unchanged (i.e., it can
// remain true if it was true before the call).
virtual Operations GetDecisionSpecialized(const SyncBuffer& sync_buffer,
const Expand& expand,
int decoder_frame_length,
const RTPHeader* packet_header,
Modes prev_mode,
bool play_dtmf,
bool* reset_decoder) OVERRIDE;
Operations GetDecisionSpecialized(const SyncBuffer& sync_buffer,
const Expand& expand,
int decoder_frame_length,
const RTPHeader* packet_header,
Modes prev_mode,
bool play_dtmf,
bool* reset_decoder) override;
private:
DISALLOW_COPY_AND_ASSIGN(DecisionLogicFax);

2
webrtc/modules/audio_coding/neteq/neteq_external_decoder_unittest.cc
View File

@ -378,7 +378,7 @@ TEST_F(LargeTimestampJumpTest, JumpLongerThanHalfRangeAndWrap) {
class ShortTimestampJumpTest : public LargeTimestampJumpTest {
protected:
void UpdateState(NetEqOutputType output_type) OVERRIDE {
void UpdateState(NetEqOutputType output_type) override {
switch (test_state_) {
case kInitialPhase: {
if (output_type == kOutputNormal) {

79
webrtc/modules/audio_coding/neteq/neteq_impl.h
View File

@ -79,10 +79,10 @@ class NetEqImpl : public webrtc::NetEq {
// of the time when the packet was received, and should be measured with
// the same tick rate as the RTP timestamp of the current payload.
// Returns 0 on success, -1 on failure.
virtual int InsertPacket(const WebRtcRTPHeader& rtp_header,
const uint8_t* payload,
size_t length_bytes,
uint32_t receive_timestamp) OVERRIDE;
int InsertPacket(const WebRtcRTPHeader& rtp_header,
const uint8_t* payload,
size_t length_bytes,
uint32_t receive_timestamp) override;
// Inserts a sync-packet into packet queue. Sync-packets are decoded to
// silence and are intended to keep AV-sync intact in an event of long packet
@ -93,8 +93,8 @@ class NetEqImpl : public webrtc::NetEq {
// type, i.e. they cannot have DTMF or CNG payload type, nor a codec change
// can be implied by inserting a sync-packet.
// Returns kOk on success, kFail on failure.
virtual int InsertSyncPacket(const WebRtcRTPHeader& rtp_header,
uint32_t receive_timestamp) OVERRIDE;
int InsertSyncPacket(const WebRtcRTPHeader& rtp_header,
uint32_t receive_timestamp) override;
// Instructs NetEq to deliver 10 ms of audio data. The data is written to
// |output_audio|, which can hold (at least) |max_length| elements.
@ -104,97 +104,98 @@ class NetEqImpl : public webrtc::NetEq {
// the samples are interleaved.
// The speech type is written to |type|, if |type| is not NULL.
// Returns kOK on success, or kFail in case of an error.
virtual int GetAudio(size_t max_length, int16_t* output_audio,
int* samples_per_channel, int* num_channels,
NetEqOutputType* type) OVERRIDE;
int GetAudio(size_t max_length,
int16_t* output_audio,
int* samples_per_channel,
int* num_channels,
NetEqOutputType* type) override;
// Associates |rtp_payload_type| with |codec| and stores the information in
// the codec database. Returns kOK on success, kFail on failure.
virtual int RegisterPayloadType(enum NetEqDecoder codec,
uint8_t rtp_payload_type) OVERRIDE;
int RegisterPayloadType(enum NetEqDecoder codec,
uint8_t rtp_payload_type) override;
// Provides an externally created decoder object |decoder| to insert in the
// decoder database. The decoder implements a decoder of type |codec| and
// associates it with |rtp_payload_type|. Returns kOK on success, kFail on
// failure.
virtual int RegisterExternalDecoder(AudioDecoder* decoder,
enum NetEqDecoder codec,
uint8_t rtp_payload_type) OVERRIDE;
int RegisterExternalDecoder(AudioDecoder* decoder,
enum NetEqDecoder codec,
uint8_t rtp_payload_type) override;
// Removes |rtp_payload_type| from the codec database. Returns 0 on success,
// -1 on failure.
virtual int RemovePayloadType(uint8_t rtp_payload_type) OVERRIDE;
int RemovePayloadType(uint8_t rtp_payload_type) override;
virtual bool SetMinimumDelay(int delay_ms) OVERRIDE;
bool SetMinimumDelay(int delay_ms) override;
virtual bool SetMaximumDelay(int delay_ms) OVERRIDE;
bool SetMaximumDelay(int delay_ms) override;
virtual int LeastRequiredDelayMs() const OVERRIDE;
int LeastRequiredDelayMs() const override;
virtual int SetTargetDelay() OVERRIDE { return kNotImplemented; }
int SetTargetDelay() override { return kNotImplemented; }
virtual int TargetDelay() OVERRIDE { return kNotImplemented; }
int TargetDelay() override { return kNotImplemented; }
virtual int CurrentDelay() OVERRIDE { return kNotImplemented; }
int CurrentDelay() override { return kNotImplemented; }
// Sets the playout mode to |mode|.
// Deprecated.
// TODO(henrik.lundin) Delete.
virtual void SetPlayoutMode(NetEqPlayoutMode mode) OVERRIDE;
void SetPlayoutMode(NetEqPlayoutMode mode) override;
// Returns the current playout mode.
// Deprecated.
// TODO(henrik.lundin) Delete.
virtual NetEqPlayoutMode PlayoutMode() const OVERRIDE;
NetEqPlayoutMode PlayoutMode() const override;
// Writes the current network statistics to |stats|. The statistics are reset
// after the call.
virtual int NetworkStatistics(NetEqNetworkStatistics* stats) OVERRIDE;
int NetworkStatistics(NetEqNetworkStatistics* stats) override;
// Writes the last packet waiting times (in ms) to |waiting_times|. The number
// of values written is no more than 100, but may be smaller if the interface
// is polled again before 100 packets has arrived.
virtual void WaitingTimes(std::vector<int>* waiting_times) OVERRIDE;
void WaitingTimes(std::vector<int>* waiting_times) override;
// Writes the current RTCP statistics to |stats|. The statistics are reset
// and a new report period is started with the call.
virtual void GetRtcpStatistics(RtcpStatistics* stats) OVERRIDE;
void GetRtcpStatistics(RtcpStatistics* stats) override;
// Same as RtcpStatistics(), but does not reset anything.
virtual void GetRtcpStatisticsNoReset(RtcpStatistics* stats) OVERRIDE;
void GetRtcpStatisticsNoReset(RtcpStatistics* stats) override;
// Enables post-decode VAD. When enabled, GetAudio() will return
// kOutputVADPassive when the signal contains no speech.
virtual void EnableVad() OVERRIDE;
void EnableVad() override;
// Disables post-decode VAD.
virtual void DisableVad() OVERRIDE;
void DisableVad() override;
virtual bool GetPlayoutTimestamp(uint32_t* timestamp) OVERRIDE;
bool GetPlayoutTimestamp(uint32_t* timestamp) override;
virtual int SetTargetNumberOfChannels() OVERRIDE { return kNotImplemented; }
int SetTargetNumberOfChannels() override { return kNotImplemented; }
virtual int SetTargetSampleRate() OVERRIDE { return kNotImplemented; }
int SetTargetSampleRate() override { return kNotImplemented; }
// Returns the error code for the last occurred error. If no error has
// occurred, 0 is returned.
virtual int LastError() const OVERRIDE;
int LastError() const override;
// Returns the error code last returned by a decoder (audio or comfort noise).
// When LastError() returns kDecoderErrorCode or kComfortNoiseErrorCode, check
// this method to get the decoder's error code.
virtual int LastDecoderError() OVERRIDE;
int LastDecoderError() override;
// Flushes both the packet buffer and the sync buffer.
virtual void FlushBuffers() OVERRIDE;
void FlushBuffers() override;
virtual void PacketBufferStatistics(int* current_num_packets,
int* max_num_packets) const OVERRIDE;
void PacketBufferStatistics(int* current_num_packets,
int* max_num_packets) const override;
// Get sequence number and timestamp of the latest RTP.
// This method is to facilitate NACK.
virtual int DecodedRtpInfo(int* sequence_number,
uint32_t* timestamp) const OVERRIDE;
int DecodedRtpInfo(int* sequence_number, uint32_t* timestamp) const override;
// This accessor method is only intended for testing purposes.
const SyncBuffer* sync_buffer_for_test() const;

6
webrtc/modules/audio_coding/neteq/test/NETEQTEST_DummyRTPpacket.h
View File

@ -15,9 +15,9 @@
class NETEQTEST_DummyRTPpacket : public NETEQTEST_RTPpacket {
public:
virtual int readFromFile(FILE* fp) OVERRIDE;
virtual int writeToFile(FILE* fp) OVERRIDE;
virtual void parseHeader() OVERRIDE;
int readFromFile(FILE* fp) override;
int writeToFile(FILE* fp) override;
void parseHeader() override;
};
#endif // NETEQTEST_DUMMYRTPPACKET_H

4
webrtc/modules/audio_coding/neteq/test/neteq_isac_quality_test.cc
View File

@ -88,8 +88,8 @@ static const bool runtime_dummy =
class NetEqIsacQualityTest : public NetEqQualityTest {
protected:
NetEqIsacQualityTest();
virtual void SetUp() OVERRIDE;
virtual void TearDown() OVERRIDE;
void SetUp() override;
void TearDown() override;
virtual int EncodeBlock(int16_t* in_data, int block_size_samples,
uint8_t* payload, int max_bytes);
private:

4
webrtc/modules/audio_coding/neteq/test/neteq_opus_fec_quality_test.cc
View File

@ -116,8 +116,8 @@ DEFINE_bool(dtx, true, "Whether to enable DTX for encoding.");
class NetEqOpusFecQualityTest : public NetEqQualityTest {
protected:
NetEqOpusFecQualityTest();
virtual void SetUp() OVERRIDE;
virtual void TearDown() OVERRIDE;
void SetUp() override;
void TearDown() override;
virtual int EncodeBlock(int16_t* in_data, int block_size_samples,
uint8_t* payload, int max_bytes);
private:

2
webrtc/modules/audio_coding/neteq/tools/audio_checksum.h
View File

@ -26,7 +26,7 @@ class AudioChecksum : public AudioSink {
public:
AudioChecksum() : finished_(false) {}
virtual bool WriteArray(const int16_t* audio, size_t num_samples) OVERRIDE {
bool WriteArray(const int16_t* audio, size_t num_samples) override {
if (finished_)
return false;

2
webrtc/modules/audio_coding/neteq/tools/audio_sink.h
View File

@ -47,7 +47,7 @@ class AudioSinkFork : public AudioSink {
AudioSinkFork(AudioSink* left, AudioSink* right)
: left_sink_(left), right_sink_(right) {}
virtual bool WriteArray(const int16_t* audio, size_t num_samples) OVERRIDE {
bool WriteArray(const int16_t* audio, size_t num_samples) override {
return left_sink_->WriteArray(audio, num_samples) &&
right_sink_->WriteArray(audio, num_samples);
}

2
webrtc/modules/audio_coding/neteq/tools/constant_pcm_packet_source.h
View File

@ -33,7 +33,7 @@ class ConstantPcmPacketSource : public PacketSource {
// Returns a pointer to the next packet. Will never return NULL. That is,
// the source is infinite.
Packet* NextPacket() OVERRIDE;
Packet* NextPacket() override;
private:
void WriteHeader(uint8_t* packet_memory);

10
webrtc/modules/audio_coding/neteq/tools/neteq_quality_test.h
View File

@ -33,13 +33,13 @@ class LossModel {
class NoLoss : public LossModel {
public:
virtual bool Lost() OVERRIDE;
bool Lost() override;
};
class UniformLoss : public LossModel {
public:
UniformLoss(double loss_rate);
virtual bool Lost() OVERRIDE;
bool Lost() override;
void set_loss_rate(double loss_rate) { loss_rate_ = loss_rate; }
private:
@ -49,7 +49,7 @@ class UniformLoss : public LossModel {
class GilbertElliotLoss : public LossModel {
public:
GilbertElliotLoss(double prob_trans_11, double prob_trans_01);
virtual bool Lost() OVERRIDE;
bool Lost() override;
private:
// Prob. of losing current packet, when previous packet is lost.
@ -69,8 +69,8 @@ class NetEqQualityTest : public ::testing::Test {
int channels,
std::string in_filename,
std::string out_filename);
virtual void SetUp() OVERRIDE;
virtual void TearDown() OVERRIDE;
void SetUp() override;
void TearDown() override;
// EncodeBlock(...) does the following:
// 1. encodes a block of audio, saved in |in_data| and has a length of

2
webrtc/modules/audio_coding/neteq/tools/output_audio_file.h
View File

@ -34,7 +34,7 @@ class OutputAudioFile : public AudioSink {
fclose(out_file_);
}
virtual bool WriteArray(const int16_t* audio, size_t num_samples) OVERRIDE {
bool WriteArray(const int16_t* audio, size_t num_samples) override {
assert(out_file_);
return fwrite(audio, sizeof(*audio), num_samples, out_file_) == num_samples;
}

2
webrtc/modules/audio_coding/neteq/tools/output_wav_file.h
View File

@ -27,7 +27,7 @@ class OutputWavFile : public AudioSink {
OutputWavFile(const std::string& file_name, int sample_rate_hz)
: wav_writer_(file_name, sample_rate_hz, 1) {}
virtual bool WriteArray(const int16_t* audio, size_t num_samples) OVERRIDE {
bool WriteArray(const int16_t* audio, size_t num_samples) override {
wav_writer_.WriteSamples(audio, num_samples);
return true;
}

2
webrtc/modules/audio_coding/neteq/tools/rtp_file_source.h
View File

@ -41,7 +41,7 @@ class RtpFileSource : public PacketSource {
// Returns a pointer to the next packet. Returns NULL if end of file was
// reached, or if a the data was corrupt.
virtual Packet* NextPacket() OVERRIDE;
Packet* NextPacket() override;
private:
static const int kFirstLineLength = 40;

2
webrtc/modules/audio_coding/neteq/tools/rtp_generator.h
View File

@ -70,7 +70,7 @@ class TimestampJumpRtpGenerator : public RtpGenerator {
uint32_t GetRtpHeader(uint8_t payload_type,
size_t payload_length_samples,
WebRtcRTPHeader* rtp_header) OVERRIDE;
WebRtcRTPHeader* rtp_header) override;
private:
uint32_t jump_from_timestamp_;