Initial VideoProcessing refactoring.

webrtc/modules/video_processing/deflickering.cc

 /*
  *  Copyright (c) 2011 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.
  */
 
@@ skipping 23 matching lines @@
 enum { kDownsamplingFactor = 8 };
 enum { kLog2OfDownsamplingFactor = 3 };
 
 // To generate in Matlab:
 // >> probUW16 = round(2^11 *
 //     [0.05,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,0.95,0.97]);
 // >> fprintf('%d, ', probUW16)
 // Resolution reduced to avoid overflow when multiplying with the
 // (potentially) large number of pixels.
 const uint16_t VPMDeflickering::prob_uw16_[kNumProbs] = {102, 205, 410, 614,
-    819, 1024, 1229, 1434, 1638, 1843, 1946, 1987}; // <Q11>
+    819, 1024, 1229, 1434, 1638, 1843, 1946, 1987};  // <Q11>
 
 // To generate in Matlab:
 // >> numQuants = 14; maxOnlyLength = 5;
 // >> weightUW16 = round(2^15 *
 //    [linspace(0.5, 1.0, numQuants - maxOnlyLength)]);
 // >> fprintf('%d, %d,\n ', weightUW16);
 const uint16_t VPMDeflickering::weight_uw16_[kNumQuants - kMaxOnlyLength] =
-    {16384, 18432, 20480, 22528, 24576, 26624, 28672, 30720, 32768}; // <Q15>
+    {16384, 18432, 20480, 22528, 24576, 26624, 28672, 30720, 32768};  // <Q15>
 
 VPMDeflickering::VPMDeflickering() {
   Reset();
 }
 
 VPMDeflickering::~VPMDeflickering() {}
 
 void VPMDeflickering::Reset() {
   mean_buffer_length_ = 0;
   detection_state_ = 0;
@@ skipping 12 matching lines @@
   }
 
   for (int32_t i = 1; i < kFrameHistory_size; i++) {
     memcpy(quant_hist_uw8_[i], quant_hist_uw8_[0],
            sizeof(uint8_t) * kNumQuants);
   }
 }
 
 int32_t VPMDeflickering::ProcessFrame(
     VideoFrame* frame,
-    VideoProcessingModule::FrameStats* stats) {
+    VideoProcessing::FrameStats* stats) {
   assert(frame);
   uint32_t frame_memory;
   uint8_t quant_uw8[kNumQuants];
   uint8_t maxquant_uw8[kNumQuants];
   uint8_t minquant_uw8[kNumQuants];
   uint16_t target_quant_uw16[kNumQuants];
   uint16_t increment_uw16;
   uint8_t map_uw8[256];
 
   uint16_t tmp_uw16;
   uint32_t tmp_uw32;
   int width = frame->width();
   int height = frame->height();
 
   if (frame->IsZeroSize()) {
     return VPM_GENERAL_ERROR;
   }
 
   // Stricter height check due to subsampling size calculation below.
   if (height < 2) {
     LOG(LS_ERROR) << "Invalid frame size.";
     return VPM_GENERAL_ERROR;
   }
 
-  if (!VideoProcessingModule::ValidFrameStats(*stats)) {
+  if (!VideoProcessing::ValidFrameStats(*stats)) {
     return VPM_GENERAL_ERROR;
   }
 
   if (PreDetection(frame->timestamp(), *stats) == -1) return VPM_GENERAL_ERROR;
 
   // Flicker detection
   int32_t det_flicker = DetectFlicker();
   if (det_flicker < 0) {
     return VPM_GENERAL_ERROR;
   } else if (det_flicker != 1) {
@@ skipping 81 matching lines @@
   // Compute the map from input to output pixels.
   uint16_t mapUW16;  // <Q7>
   for (int32_t i = 1; i < kNumQuants; i++) {
     // As quant and targetQuant are limited to UWord8, it's safe to use Q7 here.
     tmp_uw32 = static_cast<uint32_t>(target_quant_uw16[i] -
         target_quant_uw16[i - 1]);
     tmp_uw16 = static_cast<uint16_t>(quant_uw8[i] - quant_uw8[i - 1]);  // <Q0>
 
     if (tmp_uw16 > 0) {
       increment_uw16 = static_cast<uint16_t>(WebRtcSpl_DivU32U16(tmp_uw32,
-          tmp_uw16)); // <Q7>
+          tmp_uw16));  // <Q7>
     } else {
       // The value is irrelevant; the loop below will only iterate once.
       increment_uw16 = 0;
     }
 
     mapUW16 = target_quant_uw16[i - 1];
     for (uint32_t j = quant_uw8[i - 1]; j < (uint32_t)(quant_uw8[i] + 1); j++) {
       // Unsigned round. <Q0>
       map_uw8[j] = (uint8_t)((mapUW16 + (1 << 6)) >> 7);
       mapUW16 += increment_uw16;
     }
   }
 
   // Map to the output frame.
   uint8_t* buffer = frame->buffer(kYPlane);
   for (uint32_t i = 0; i < y_size; i++) {
     buffer[i] = map_uw8[buffer[i]];
   }
 
   // Frame was altered, so reset stats.
-  VideoProcessingModule::ClearFrameStats(stats);
+  VideoProcessing::ClearFrameStats(stats);
 
   return VPM_OK;
 }
 
 /**
    Performs some pre-detection operations. Must be called before
    DetectFlicker().
 
    \param[in] timestamp Timestamp of the current frame.
    \param[in] stats     Statistics of the current frame.
 
    \return 0: Success\n
            2: Detection not possible due to flickering frequency too close to
               zero.\n
           -1: Error
 */
 int32_t VPMDeflickering::PreDetection(const uint32_t timestamp,
-  const VideoProcessingModule::FrameStats& stats) {
+  const VideoProcessing::FrameStats& stats) {
   int32_t mean_val;  // Mean value of frame (Q4)
   uint32_t frame_rate = 0;
   int32_t meanBufferLength;  // Temp variable.
 
   mean_val = ((stats.sum << kmean_valueScaling) / stats.num_pixels);
   // Update mean value buffer.
   // This should be done even though we might end up in an unreliable detection.
   memmove(mean_buffer_ + 1, mean_buffer_,
       (kMeanBufferLength - 1) * sizeof(int32_t));
   mean_buffer_[0] = mean_val;
@@ skipping 102 matching lines @@
       (timestamp_buffer_[0] - timestamp_buffer_[mean_buffer_length_ - 1]);
 
   /* Translate frequency estimate to regions close to 100 and 120 Hz */
   uint8_t freqState = 0;  // Current translation state;
                           // (0) Not in interval,
                           // (1) Within valid interval,
                           // (2) Out of range
   int32_t freqAlias = freqEst;
   if (freqEst > kMinFrequencyToDetect) {
     uint8_t aliasState = 1;
-    while(freqState == 0) {
+    while (freqState == 0) {
       /* Increase frequency */
       freqAlias += (aliasState * frame_rate_);
       freqAlias += ((freqEst << 1) * (1 - (aliasState << 1)));
       /* Compute state */
       freqState = (abs(freqAlias - (100 << 4)) <= kFrequencyDeviation);
       freqState += (abs(freqAlias - (120 << 4)) <= kFrequencyDeviation);
       freqState += 2 * (freqAlias > ((120 << 4) + kFrequencyDeviation));
       /* Switch alias state */
       aliasState++;
       aliasState &= 0x01;
     }
   }
   /* Is frequency estimate within detection region? */
   if (freqState == 1) {
     ret_val = 1;
   } else if (freqState == 0) {
     ret_val = 2;
   } else {
     ret_val = 0;
   }
   return ret_val;
 }
 
 }  // namespace webrtc