diff options
Diffstat (limited to 'webrtc/modules/video_processing/video_processing_impl.cc')
| -rw-r--r-- | webrtc/modules/video_processing/video_processing_impl.cc | 179 |
1 files changed, 179 insertions, 0 deletions
diff --git a/webrtc/modules/video_processing/video_processing_impl.cc b/webrtc/modules/video_processing/video_processing_impl.cc new file mode 100644 index 0000000000..f34886f10f --- /dev/null +++ b/webrtc/modules/video_processing/video_processing_impl.cc @@ -0,0 +1,179 @@ +/* + * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "webrtc/modules/video_processing/video_processing_impl.h" + +#include <assert.h> + +#include "webrtc/base/checks.h" +#include "webrtc/base/logging.h" +#include "webrtc/system_wrappers/include/critical_section_wrapper.h" + +namespace webrtc { + +namespace { + +int GetSubSamplingFactor(int width, int height) { + if (width * height >= 640 * 480) { + return 3; + } else if (width * height >= 352 * 288) { + return 2; + } else if (width * height >= 176 * 144) { + return 1; + } else { + return 0; + } +} +} // namespace + +VideoProcessing* VideoProcessing::Create() { + return new VideoProcessingImpl(); +} + +VideoProcessingImpl::VideoProcessingImpl() {} +VideoProcessingImpl::~VideoProcessingImpl() {} + +void VideoProcessing::GetFrameStats(const VideoFrame& frame, + FrameStats* stats) { + ClearFrameStats(stats); // The histogram needs to be zeroed out. + if (frame.IsZeroSize()) { + return; + } + + int width = frame.width(); + int height = frame.height(); + stats->sub_sampling_factor = GetSubSamplingFactor(width, height); + + const uint8_t* buffer = frame.buffer(kYPlane); + // Compute histogram and sum of frame + for (int i = 0; i < height; i += (1 << stats->sub_sampling_factor)) { + int k = i * width; + for (int j = 0; j < width; j += (1 << stats->sub_sampling_factor)) { + stats->hist[buffer[k + j]]++; + stats->sum += buffer[k + j]; + } + } + + stats->num_pixels = (width * height) / ((1 << stats->sub_sampling_factor) * + (1 << stats->sub_sampling_factor)); + assert(stats->num_pixels > 0); + + // Compute mean value of frame + stats->mean = stats->sum / stats->num_pixels; +} + +bool VideoProcessing::ValidFrameStats(const FrameStats& stats) { + if (stats.num_pixels == 0) { + LOG(LS_WARNING) << "Invalid frame stats."; + return false; + } + return true; +} + +void VideoProcessing::ClearFrameStats(FrameStats* stats) { + stats->mean = 0; + stats->sum = 0; + stats->num_pixels = 0; + stats->sub_sampling_factor = 0; + memset(stats->hist, 0, sizeof(stats->hist)); +} + +void VideoProcessing::Brighten(int delta, VideoFrame* frame) { + RTC_DCHECK(!frame->IsZeroSize()); + RTC_DCHECK(frame->width() > 0); + RTC_DCHECK(frame->height() > 0); + + int num_pixels = frame->width() * frame->height(); + + int look_up[256]; + for (int i = 0; i < 256; i++) { + int val = i + delta; + look_up[i] = ((((val < 0) ? 0 : val) > 255) ? 255 : val); + } + + uint8_t* temp_ptr = frame->buffer(kYPlane); + for (int i = 0; i < num_pixels; i++) { + *temp_ptr = static_cast<uint8_t>(look_up[*temp_ptr]); + temp_ptr++; + } +} + +int32_t VideoProcessingImpl::Deflickering(VideoFrame* frame, + FrameStats* stats) { + rtc::CritScope mutex(&mutex_); + return deflickering_.ProcessFrame(frame, stats); +} + +int32_t VideoProcessingImpl::BrightnessDetection(const VideoFrame& frame, + const FrameStats& stats) { + rtc::CritScope mutex(&mutex_); + return brightness_detection_.ProcessFrame(frame, stats); +} + +void VideoProcessingImpl::EnableTemporalDecimation(bool enable) { + rtc::CritScope mutex(&mutex_); + frame_pre_processor_.EnableTemporalDecimation(enable); +} + +void VideoProcessingImpl::SetInputFrameResampleMode( + VideoFrameResampling resampling_mode) { + rtc::CritScope cs(&mutex_); + frame_pre_processor_.SetInputFrameResampleMode(resampling_mode); +} + +int32_t VideoProcessingImpl::SetTargetResolution(uint32_t width, + uint32_t height, + uint32_t frame_rate) { + rtc::CritScope cs(&mutex_); + return frame_pre_processor_.SetTargetResolution(width, height, frame_rate); +} + +void VideoProcessingImpl::SetTargetFramerate(int frame_rate) { + rtc::CritScope cs(&mutex_); + frame_pre_processor_.SetTargetFramerate(frame_rate); +} + +uint32_t VideoProcessingImpl::GetDecimatedFrameRate() { + rtc::CritScope cs(&mutex_); + return frame_pre_processor_.GetDecimatedFrameRate(); +} + +uint32_t VideoProcessingImpl::GetDecimatedWidth() const { + rtc::CritScope cs(&mutex_); + return frame_pre_processor_.GetDecimatedWidth(); +} + +uint32_t VideoProcessingImpl::GetDecimatedHeight() const { + rtc::CritScope cs(&mutex_); + return frame_pre_processor_.GetDecimatedHeight(); +} + +void VideoProcessingImpl::EnableDenosing(bool enable) { + rtc::CritScope cs(&mutex_); + frame_pre_processor_.EnableDenosing(enable); +} + +const VideoFrame* VideoProcessingImpl::PreprocessFrame( + const VideoFrame& frame) { + rtc::CritScope mutex(&mutex_); + return frame_pre_processor_.PreprocessFrame(frame); +} + +VideoContentMetrics* VideoProcessingImpl::GetContentMetrics() const { + rtc::CritScope mutex(&mutex_); + return frame_pre_processor_.GetContentMetrics(); +} + +void VideoProcessingImpl::EnableContentAnalysis(bool enable) { + rtc::CritScope mutex(&mutex_); + frame_pre_processor_.EnableContentAnalysis(enable); +} + +} // namespace webrtc |