git-svn-id: http://webrtc.googlecode.com/svn/trunk@4 4adac7df-926f-26a2-2b94-8c16560cd09d

modules/video_coding/main/source/content_metrics_processing.cc

@@ -0,0 +1,225 @@
+/*
+ *  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.
+ */
+
+#include "content_metrics_processing.h"
+#include "tick_time.h"
+#include "module_common_types.h"
+#include "video_coding_defines.h"
+
+#include <math.h>
+
+namespace webrtc {
+
+//////////////////////////////////
+/// VCMContentMetricsProcessing //
+//////////////////////////////////
+
+VCMContentMetricsProcessing::VCMContentMetricsProcessing():
+_frameRate(0),
+_recAvgFactor(1 / 150.0f), // matched to  30fps
+_frameCnt(0),
+_prevAvgSizeZeroMotion(0),
+_avgSizeZeroMotion(0),
+_prevAvgSpatialPredErr(0),
+_avgSpatialPredErr(0),
+_frameCntForCC(0),
+_lastCCpdateTime(0)
+{
+    _globalRecursiveAvg = new VideoContentMetrics();
+}
+
+VCMContentMetricsProcessing::~VCMContentMetricsProcessing()
+{
+    delete _globalRecursiveAvg;
+}
+
+WebRtc_Word32
+VCMContentMetricsProcessing::Reset()
+{
+    _globalRecursiveAvg->Reset();
+    _frameCnt = 0;
+    _frameRate = 0;
+    //_recAvgFactor = 1 / 150.0f; // matched to 30 fps
+    _prevAvgSizeZeroMotion = 0;
+    _avgSizeZeroMotion = 0;
+    _prevAvgSpatialPredErr = 0;
+    _avgSpatialPredErr = 0;
+    _frameCntForCC = 0;
+
+    return VCM_OK;
+}
+void
+VCMContentMetricsProcessing::UpdateFrameRate(WebRtc_UWord32 frameRate)
+{
+    _frameRate = frameRate;
+    //Update recursive avg factor
+    _recAvgFactor = (float) 1000 / ((float)(_frameRate *  kQmMinIntervalMs));
+
+}
+
+WebRtc_Word32
+VCMContentMetricsProcessing::UpdateContentData(const VideoContentMetrics *contentMetrics)
+{
+    if (contentMetrics == NULL)
+    {
+        return VCM_OK;
+    }
+    return ProcessContent(contentMetrics);
+
+}
+
+VideoContentMetrics*
+VCMContentMetricsProcessing::Data()
+{
+    if (_frameCnt == 0)
+    {
+        return NULL;
+    }
+    return _globalRecursiveAvg;
+}
+
+WebRtc_UWord32
+VCMContentMetricsProcessing::ProcessContent(const VideoContentMetrics *contentMetrics)
+{
+    // update global metric
+    UpdateGlobalMetric(contentMetrics);
+
+    //Update metrics over local window for content change (CC) detection:
+    //two metrics are used for CC detection: size of zero motion, and spatial prediction error
+    //Not currently used:
+    //UpdateLocalMetricCC(contentMetrics->sizeZeroMotion, contentMetrics->spatialPredErr);
+
+    return VCM_OK;
+}
+
+bool
+VCMContentMetricsProcessing::ContentChangeCheck()
+{
+     bool result = false;
+
+    // Thresholds for bitrate and content change detection
+    float qmContentChangePercMotion = 0.4f;
+    float qmContentChangePercSpatial = 0.4f;
+
+    WebRtc_Word64 now = VCMTickTime::MillisecondTimestamp();
+    if ( (now - _lastCCpdateTime) < kCcMinIntervalMs)
+    {
+        //keep averaging
+        return result;
+    }
+    else //check for detection and reset
+    {
+        //normalize
+        _avgSizeZeroMotion = _avgSizeZeroMotion / (float)(_frameCntForCC);
+        _prevAvgSpatialPredErr = _prevAvgSpatialPredErr / (float)(_frameCntForCC);
+
+        //check for content change
+        float diffMotion = fabs(_avgSizeZeroMotion - _prevAvgSizeZeroMotion);
+        float diffSpatial = fabs(_avgSpatialPredErr -_prevAvgSpatialPredErr);
+        if ((diffMotion > (_avgSizeZeroMotion * qmContentChangePercMotion)) ||
+            (diffSpatial > (_prevAvgSpatialPredErr * qmContentChangePercSpatial)))
+        {
+            result = true;
+        }
+
+        //copy to previous
+        _prevAvgSizeZeroMotion = _avgSizeZeroMotion;
+        _prevAvgSpatialPredErr = _avgSpatialPredErr;
+
+        //reset
+        _avgSizeZeroMotion = 0.;
+        _avgSpatialPredErr = 0.;
+        _frameCntForCC = 0;
+
+         _lastCCpdateTime = now;
+
+    }
+
+    return result;
+}
+
+//update metrics for content change detection: update is uniform average over soem time window
+void VCMContentMetricsProcessing::UpdateLocalMetricCC(float motionVal, float spatialVal)
+{
+
+    _frameCntForCC += 1;
+    _avgSizeZeroMotion += motionVal;
+    _avgSpatialPredErr += spatialVal;
+
+    return;
+
+}
+void
+VCMContentMetricsProcessing::UpdateGlobalMetric(const VideoContentMetrics *contentMetrics)
+{
+
+    // Threshold for size of zero motion cluster: for updating 3 metrics:
+    // motion magnitude, cluster distortion, and horizontalness
+    float nonZeroMvThr = 0.1f;
+
+    // first zero and one: take value as is (no motion search in frame zero).
+    float tmpRecAvgFactor  = _recAvgFactor;
+    if (_frameCnt < 1)
+    {
+        _recAvgFactor = 1;
+    }
+
+    _globalRecursiveAvg->motionPredErr = (1 - _recAvgFactor) * _globalRecursiveAvg->motionPredErr +
+                                          _recAvgFactor * contentMetrics->motionPredErr;
+
+    _globalRecursiveAvg->sizeZeroMotion = (1 - _recAvgFactor) * _globalRecursiveAvg->sizeZeroMotion +
+                                           _recAvgFactor * contentMetrics->sizeZeroMotion;
+
+    _globalRecursiveAvg->spatialPredErr = (1 - _recAvgFactor) * _globalRecursiveAvg->spatialPredErr +
+                                           _recAvgFactor * contentMetrics->spatialPredErr;
+
+    _globalRecursiveAvg->spatialPredErrH = (1 - _recAvgFactor) * _globalRecursiveAvg->spatialPredErrH +
+                                           _recAvgFactor * contentMetrics->spatialPredErrH;
+
+    _globalRecursiveAvg->spatialPredErrV = (1 - _recAvgFactor) * _globalRecursiveAvg->spatialPredErrV +
+                                           _recAvgFactor * contentMetrics->spatialPredErrV;
+
+    //motionMag metric is derived from NFD (normalized frame difference)
+    if (kNfdMetric == 1)
+    {
+        _globalRecursiveAvg->motionMagnitudeNZ = (1 - _recAvgFactor) * _globalRecursiveAvg->motionMagnitudeNZ +
+                                                    _recAvgFactor * contentMetrics->motionMagnitudeNZ;
+    }
+
+    if (contentMetrics->sizeZeroMotion > nonZeroMvThr)
+    {
+        _globalRecursiveAvg->motionClusterDistortion = (1 - _recAvgFactor) * _globalRecursiveAvg->motionClusterDistortion +
+                                                    _recAvgFactor *contentMetrics->motionClusterDistortion;
+
+        _globalRecursiveAvg->motionHorizontalness = (1 - _recAvgFactor) * _globalRecursiveAvg->motionHorizontalness +
+                                                _recAvgFactor * contentMetrics->motionHorizontalness;
+
+        //motionMag metric is derived from motion vectors
+        if (kNfdMetric == 0)
+        {
+            _globalRecursiveAvg->motionMagnitudeNZ = (1 - _recAvgFactor) * _globalRecursiveAvg->motionMagnitudeNZ +
+                                                _recAvgFactor * contentMetrics->motionMagnitudeNZ;
+        }
+    }
+
+    // update native values:
+    _globalRecursiveAvg->nativeHeight = contentMetrics->nativeHeight;
+    _globalRecursiveAvg->nativeWidth = contentMetrics->nativeWidth;
+    _globalRecursiveAvg->nativeFrameRate = contentMetrics->nativeFrameRate;
+
+    if (_frameCnt < 1)
+    {
+        _recAvgFactor = tmpRecAvgFactor;
+    }
+    _frameCnt++;
+    return;
+}
+
+}