xref: /external/webrtc/webrtc/modules/video_processing/video_processing_impl.cc

/*
 *  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