Lint fix for webrtc/modules/video_coding PART 3! Trying to submit all changes at once proved impossible since there were too many changes in too many files. The changes to PRESUBMIT.py will be uploaded in the last CL. (original CL: https://codereview.webrtc.org/1528503003/) BUG=webrtc:5309 TBR=mflodman@webrtc.org Review URL: https://codereview.webrtc.org/1540243002 Cr-Commit-Position: refs/heads/master@{#11105}
diff --git a/webrtc/modules/video_coding/utility/frame_dropper.cc b/webrtc/modules/video_coding/utility/frame_dropper.cc index dfa7df8..a0aa67b 100644 --- a/webrtc/modules/video_coding/utility/frame_dropper.cc +++ b/webrtc/modules/video_coding/utility/frame_dropper.cc
@@ -12,8 +12,7 @@ #include "webrtc/system_wrappers/include/trace.h" -namespace webrtc -{ +namespace webrtc { const float kDefaultKeyFrameSizeAvgKBits = 0.9f; const float kDefaultKeyFrameRatio = 0.99f; @@ -22,339 +21,266 @@ const float kDefaultMaxTimeToDropFrames = 4.0f; // In seconds. FrameDropper::FrameDropper() -: -_keyFrameSizeAvgKbits(kDefaultKeyFrameSizeAvgKBits), -_keyFrameRatio(kDefaultKeyFrameRatio), -_dropRatio(kDefaultDropRatioAlpha, kDefaultDropRatioMax), -_enabled(true), -_max_time_drops(kDefaultMaxTimeToDropFrames) -{ - Reset(); + : _keyFrameSizeAvgKbits(kDefaultKeyFrameSizeAvgKBits), + _keyFrameRatio(kDefaultKeyFrameRatio), + _dropRatio(kDefaultDropRatioAlpha, kDefaultDropRatioMax), + _enabled(true), + _max_time_drops(kDefaultMaxTimeToDropFrames) { + Reset(); } FrameDropper::FrameDropper(float max_time_drops) -: -_keyFrameSizeAvgKbits(kDefaultKeyFrameSizeAvgKBits), -_keyFrameRatio(kDefaultKeyFrameRatio), -_dropRatio(kDefaultDropRatioAlpha, kDefaultDropRatioMax), -_enabled(true), -_max_time_drops(max_time_drops) -{ - Reset(); + : _keyFrameSizeAvgKbits(kDefaultKeyFrameSizeAvgKBits), + _keyFrameRatio(kDefaultKeyFrameRatio), + _dropRatio(kDefaultDropRatioAlpha, kDefaultDropRatioMax), + _enabled(true), + _max_time_drops(max_time_drops) { + Reset(); } -void -FrameDropper::Reset() -{ - _keyFrameRatio.Reset(0.99f); - _keyFrameRatio.Apply(1.0f, 1.0f/300.0f); // 1 key frame every 10th second in 30 fps - _keyFrameSizeAvgKbits.Reset(0.9f); - _keyFrameCount = 0; +void FrameDropper::Reset() { + _keyFrameRatio.Reset(0.99f); + _keyFrameRatio.Apply( + 1.0f, 1.0f / 300.0f); // 1 key frame every 10th second in 30 fps + _keyFrameSizeAvgKbits.Reset(0.9f); + _keyFrameCount = 0; + _accumulator = 0.0f; + _accumulatorMax = 150.0f; // assume 300 kb/s and 0.5 s window + _targetBitRate = 300.0f; + _incoming_frame_rate = 30; + _keyFrameSpreadFrames = 0.5f * _incoming_frame_rate; + _dropNext = false; + _dropRatio.Reset(0.9f); + _dropRatio.Apply(0.0f, 0.0f); // Initialize to 0 + _dropCount = 0; + _windowSize = 0.5f; + _wasBelowMax = true; + _fastMode = false; // start with normal (non-aggressive) mode + // Cap for the encoder buffer level/accumulator, in secs. + _cap_buffer_size = 3.0f; + // Cap on maximum amount of dropped frames between kept frames, in secs. + _max_time_drops = 4.0f; +} + +void FrameDropper::Enable(bool enable) { + _enabled = enable; +} + +void FrameDropper::Fill(size_t frameSizeBytes, bool deltaFrame) { + if (!_enabled) { + return; + } + float frameSizeKbits = 8.0f * static_cast<float>(frameSizeBytes) / 1000.0f; + if (!deltaFrame && + !_fastMode) { // fast mode does not treat key-frames any different + _keyFrameSizeAvgKbits.Apply(1, frameSizeKbits); + _keyFrameRatio.Apply(1.0, 1.0); + if (frameSizeKbits > _keyFrameSizeAvgKbits.filtered()) { + // Remove the average key frame size since we + // compensate for key frames when adding delta + // frames. + frameSizeKbits -= _keyFrameSizeAvgKbits.filtered(); + } else { + // Shouldn't be negative, so zero is the lower bound. + frameSizeKbits = 0; + } + if (_keyFrameRatio.filtered() > 1e-5 && + 1 / _keyFrameRatio.filtered() < _keyFrameSpreadFrames) { + // We are sending key frames more often than our upper bound for + // how much we allow the key frame compensation to be spread + // out in time. Therefor we must use the key frame ratio rather + // than keyFrameSpreadFrames. + _keyFrameCount = + static_cast<int32_t>(1 / _keyFrameRatio.filtered() + 0.5); + } else { + // Compensate for the key frame the following frames + _keyFrameCount = static_cast<int32_t>(_keyFrameSpreadFrames + 0.5); + } + } else { + // Decrease the keyFrameRatio + _keyFrameRatio.Apply(1.0, 0.0); + } + // Change the level of the accumulator (bucket) + _accumulator += frameSizeKbits; + CapAccumulator(); +} + +void FrameDropper::Leak(uint32_t inputFrameRate) { + if (!_enabled) { + return; + } + if (inputFrameRate < 1) { + return; + } + if (_targetBitRate < 0.0f) { + return; + } + _keyFrameSpreadFrames = 0.5f * inputFrameRate; + // T is the expected bits per frame (target). If all frames were the same + // size, + // we would get T bits per frame. Notice that T is also weighted to be able to + // force a lower frame rate if wanted. + float T = _targetBitRate / inputFrameRate; + if (_keyFrameCount > 0) { + // Perform the key frame compensation + if (_keyFrameRatio.filtered() > 0 && + 1 / _keyFrameRatio.filtered() < _keyFrameSpreadFrames) { + T -= _keyFrameSizeAvgKbits.filtered() * _keyFrameRatio.filtered(); + } else { + T -= _keyFrameSizeAvgKbits.filtered() / _keyFrameSpreadFrames; + } + _keyFrameCount--; + } + _accumulator -= T; + if (_accumulator < 0.0f) { _accumulator = 0.0f; - _accumulatorMax = 150.0f; // assume 300 kb/s and 0.5 s window - _targetBitRate = 300.0f; - _incoming_frame_rate = 30; - _keyFrameSpreadFrames = 0.5f * _incoming_frame_rate; - _dropNext = false; - _dropRatio.Reset(0.9f); - _dropRatio.Apply(0.0f, 0.0f); // Initialize to 0 - _dropCount = 0; - _windowSize = 0.5f; - _wasBelowMax = true; - _fastMode = false; // start with normal (non-aggressive) mode - // Cap for the encoder buffer level/accumulator, in secs. - _cap_buffer_size = 3.0f; - // Cap on maximum amount of dropped frames between kept frames, in secs. - _max_time_drops = 4.0f; + } + UpdateRatio(); } -void -FrameDropper::Enable(bool enable) -{ - _enabled = enable; +void FrameDropper::UpdateNack(uint32_t nackBytes) { + if (!_enabled) { + return; + } + _accumulator += static_cast<float>(nackBytes) * 8.0f / 1000.0f; } -void -FrameDropper::Fill(size_t frameSizeBytes, bool deltaFrame) -{ - if (!_enabled) - { - return; - } - float frameSizeKbits = 8.0f * static_cast<float>(frameSizeBytes) / 1000.0f; - if (!deltaFrame && !_fastMode) // fast mode does not treat key-frames any different - { - _keyFrameSizeAvgKbits.Apply(1, frameSizeKbits); - _keyFrameRatio.Apply(1.0, 1.0); - if (frameSizeKbits > _keyFrameSizeAvgKbits.filtered()) - { - // Remove the average key frame size since we - // compensate for key frames when adding delta - // frames. - frameSizeKbits -= _keyFrameSizeAvgKbits.filtered(); - } - else - { - // Shouldn't be negative, so zero is the lower bound. - frameSizeKbits = 0; - } - if (_keyFrameRatio.filtered() > 1e-5 && - 1 / _keyFrameRatio.filtered() < _keyFrameSpreadFrames) - { - // We are sending key frames more often than our upper bound for - // how much we allow the key frame compensation to be spread - // out in time. Therefor we must use the key frame ratio rather - // than keyFrameSpreadFrames. - _keyFrameCount = - static_cast<int32_t>(1 / _keyFrameRatio.filtered() + 0.5); - } - else - { - // Compensate for the key frame the following frames - _keyFrameCount = static_cast<int32_t>(_keyFrameSpreadFrames + 0.5); - } - } - else - { - // Decrease the keyFrameRatio - _keyFrameRatio.Apply(1.0, 0.0); - } - // Change the level of the accumulator (bucket) - _accumulator += frameSizeKbits; - CapAccumulator(); +void FrameDropper::FillBucket(float inKbits, float outKbits) { + _accumulator += (inKbits - outKbits); } -void -FrameDropper::Leak(uint32_t inputFrameRate) -{ - if (!_enabled) - { - return; +void FrameDropper::UpdateRatio() { + if (_accumulator > 1.3f * _accumulatorMax) { + // Too far above accumulator max, react faster + _dropRatio.UpdateBase(0.8f); + } else { + // Go back to normal reaction + _dropRatio.UpdateBase(0.9f); + } + if (_accumulator > _accumulatorMax) { + // We are above accumulator max, and should ideally + // drop a frame. Increase the dropRatio and drop + // the frame later. + if (_wasBelowMax) { + _dropNext = true; } - if (inputFrameRate < 1) - { - return; + if (_fastMode) { + // always drop in aggressive mode + _dropNext = true; } - if (_targetBitRate < 0.0f) - { - return; - } - _keyFrameSpreadFrames = 0.5f * inputFrameRate; - // T is the expected bits per frame (target). If all frames were the same size, - // we would get T bits per frame. Notice that T is also weighted to be able to - // force a lower frame rate if wanted. - float T = _targetBitRate / inputFrameRate; - if (_keyFrameCount > 0) - { - // Perform the key frame compensation - if (_keyFrameRatio.filtered() > 0 && - 1 / _keyFrameRatio.filtered() < _keyFrameSpreadFrames) - { - T -= _keyFrameSizeAvgKbits.filtered() * _keyFrameRatio.filtered(); - } - else - { - T -= _keyFrameSizeAvgKbits.filtered() / _keyFrameSpreadFrames; - } - _keyFrameCount--; - } - _accumulator -= T; - if (_accumulator < 0.0f) - { - _accumulator = 0.0f; - } - UpdateRatio(); + + _dropRatio.Apply(1.0f, 1.0f); + _dropRatio.UpdateBase(0.9f); + } else { + _dropRatio.Apply(1.0f, 0.0f); + } + _wasBelowMax = _accumulator < _accumulatorMax; } -void -FrameDropper::UpdateNack(uint32_t nackBytes) -{ - if (!_enabled) - { - return; - } - _accumulator += static_cast<float>(nackBytes) * 8.0f / 1000.0f; -} - -void -FrameDropper::FillBucket(float inKbits, float outKbits) -{ - _accumulator += (inKbits - outKbits); -} - -void -FrameDropper::UpdateRatio() -{ - if (_accumulator > 1.3f * _accumulatorMax) - { - // Too far above accumulator max, react faster - _dropRatio.UpdateBase(0.8f); - } - else - { - // Go back to normal reaction - _dropRatio.UpdateBase(0.9f); - } - if (_accumulator > _accumulatorMax) - { - // We are above accumulator max, and should ideally - // drop a frame. Increase the dropRatio and drop - // the frame later. - if (_wasBelowMax) - { - _dropNext = true; - } - if (_fastMode) - { - // always drop in aggressive mode - _dropNext = true; - } - - _dropRatio.Apply(1.0f, 1.0f); - _dropRatio.UpdateBase(0.9f); - } - else - { - _dropRatio.Apply(1.0f, 0.0f); - } - _wasBelowMax = _accumulator < _accumulatorMax; -} - -// This function signals when to drop frames to the caller. It makes use of the dropRatio +// This function signals when to drop frames to the caller. It makes use of the +// dropRatio // to smooth out the drops over time. -bool -FrameDropper::DropFrame() -{ - if (!_enabled) - { - return false; - } - if (_dropNext) - { - _dropNext = false; - _dropCount = 0; - } - - if (_dropRatio.filtered() >= 0.5f) // Drops per keep - { - // limit is the number of frames we should drop between each kept frame - // to keep our drop ratio. limit is positive in this case. - float denom = 1.0f - _dropRatio.filtered(); - if (denom < 1e-5) - { - denom = (float)1e-5; - } - int32_t limit = static_cast<int32_t>(1.0f / denom - 1.0f + 0.5f); - // Put a bound on the max amount of dropped frames between each kept - // frame, in terms of frame rate and window size (secs). - int max_limit = static_cast<int>(_incoming_frame_rate * - _max_time_drops); - if (limit > max_limit) { - limit = max_limit; - } - if (_dropCount < 0) - { - // Reset the _dropCount since it was negative and should be positive. - if (_dropRatio.filtered() > 0.4f) - { - _dropCount = -_dropCount; - } - else - { - _dropCount = 0; - } - } - if (_dropCount < limit) - { - // As long we are below the limit we should drop frames. - _dropCount++; - return true; - } - else - { - // Only when we reset _dropCount a frame should be kept. - _dropCount = 0; - return false; - } - } - else if (_dropRatio.filtered() > 0.0f && - _dropRatio.filtered() < 0.5f) // Keeps per drop - { - // limit is the number of frames we should keep between each drop - // in order to keep the drop ratio. limit is negative in this case, - // and the _dropCount is also negative. - float denom = _dropRatio.filtered(); - if (denom < 1e-5) - { - denom = (float)1e-5; - } - int32_t limit = -static_cast<int32_t>(1.0f / denom - 1.0f + 0.5f); - if (_dropCount > 0) - { - // Reset the _dropCount since we have a positive - // _dropCount, and it should be negative. - if (_dropRatio.filtered() < 0.6f) - { - _dropCount = -_dropCount; - } - else - { - _dropCount = 0; - } - } - if (_dropCount > limit) - { - if (_dropCount == 0) - { - // Drop frames when we reset _dropCount. - _dropCount--; - return true; - } - else - { - // Keep frames as long as we haven't reached limit. - _dropCount--; - return false; - } - } - else - { - _dropCount = 0; - return false; - } - } - _dropCount = 0; +bool FrameDropper::DropFrame() { + if (!_enabled) { return false; + } + if (_dropNext) { + _dropNext = false; + _dropCount = 0; + } - // A simpler version, unfiltered and quicker - //bool dropNext = _dropNext; - //_dropNext = false; - //return dropNext; + if (_dropRatio.filtered() >= 0.5f) { // Drops per keep + // limit is the number of frames we should drop between each kept frame + // to keep our drop ratio. limit is positive in this case. + float denom = 1.0f - _dropRatio.filtered(); + if (denom < 1e-5) { + denom = 1e-5f; + } + int32_t limit = static_cast<int32_t>(1.0f / denom - 1.0f + 0.5f); + // Put a bound on the max amount of dropped frames between each kept + // frame, in terms of frame rate and window size (secs). + int max_limit = static_cast<int>(_incoming_frame_rate * _max_time_drops); + if (limit > max_limit) { + limit = max_limit; + } + if (_dropCount < 0) { + // Reset the _dropCount since it was negative and should be positive. + if (_dropRatio.filtered() > 0.4f) { + _dropCount = -_dropCount; + } else { + _dropCount = 0; + } + } + if (_dropCount < limit) { + // As long we are below the limit we should drop frames. + _dropCount++; + return true; + } else { + // Only when we reset _dropCount a frame should be kept. + _dropCount = 0; + return false; + } + } else if (_dropRatio.filtered() > 0.0f && + _dropRatio.filtered() < 0.5f) { // Keeps per drop + // limit is the number of frames we should keep between each drop + // in order to keep the drop ratio. limit is negative in this case, + // and the _dropCount is also negative. + float denom = _dropRatio.filtered(); + if (denom < 1e-5) { + denom = 1e-5f; + } + int32_t limit = -static_cast<int32_t>(1.0f / denom - 1.0f + 0.5f); + if (_dropCount > 0) { + // Reset the _dropCount since we have a positive + // _dropCount, and it should be negative. + if (_dropRatio.filtered() < 0.6f) { + _dropCount = -_dropCount; + } else { + _dropCount = 0; + } + } + if (_dropCount > limit) { + if (_dropCount == 0) { + // Drop frames when we reset _dropCount. + _dropCount--; + return true; + } else { + // Keep frames as long as we haven't reached limit. + _dropCount--; + return false; + } + } else { + _dropCount = 0; + return false; + } + } + _dropCount = 0; + return false; + + // A simpler version, unfiltered and quicker + // bool dropNext = _dropNext; + // _dropNext = false; + // return dropNext; } -void -FrameDropper::SetRates(float bitRate, float incoming_frame_rate) -{ - // Bit rate of -1 means infinite bandwidth. - _accumulatorMax = bitRate * _windowSize; // bitRate * windowSize (in seconds) - if (_targetBitRate > 0.0f && bitRate < _targetBitRate && _accumulator > _accumulatorMax) - { - // Rescale the accumulator level if the accumulator max decreases - _accumulator = bitRate / _targetBitRate * _accumulator; - } - _targetBitRate = bitRate; - CapAccumulator(); - _incoming_frame_rate = incoming_frame_rate; +void FrameDropper::SetRates(float bitRate, float incoming_frame_rate) { + // Bit rate of -1 means infinite bandwidth. + _accumulatorMax = bitRate * _windowSize; // bitRate * windowSize (in seconds) + if (_targetBitRate > 0.0f && bitRate < _targetBitRate && + _accumulator > _accumulatorMax) { + // Rescale the accumulator level if the accumulator max decreases + _accumulator = bitRate / _targetBitRate * _accumulator; + } + _targetBitRate = bitRate; + CapAccumulator(); + _incoming_frame_rate = incoming_frame_rate; } -float -FrameDropper::ActualFrameRate(uint32_t inputFrameRate) const -{ - if (!_enabled) - { - return static_cast<float>(inputFrameRate); - } - return inputFrameRate * (1.0f - _dropRatio.filtered()); +float FrameDropper::ActualFrameRate(uint32_t inputFrameRate) const { + if (!_enabled) { + return static_cast<float>(inputFrameRate); + } + return inputFrameRate * (1.0f - _dropRatio.filtered()); } // Put a cap on the accumulator, i.e., don't let it grow beyond some level. @@ -366,5 +292,4 @@ _accumulator = max_accumulator; } } - -} +} // namespace webrtc