git-svn-id: http://webrtc.googlecode.com/svn/trunk@4 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
niklase@google.com
684
modules/video_coding/main/source/qm_select.cc
Normal file
684
modules/video_coding/main/source/qm_select.cc
Normal file
@@ -0,0 +1,684 @@
|
||||
/*
|
||||
* 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 "qm_select.h"
|
||||
#include "internal_defines.h"
|
||||
#include "qm_select_data.h"
|
||||
|
||||
#include "module_common_types.h"
|
||||
#include "video_coding_defines.h"
|
||||
#include "trace.h"
|
||||
|
||||
#include <math.h>
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
VCMQmSelect::VCMQmSelect()
|
||||
{
|
||||
_qm = new VCMQualityMode();
|
||||
Reset();
|
||||
}
|
||||
|
||||
VCMQmSelect::~VCMQmSelect()
|
||||
{
|
||||
delete _qm;
|
||||
}
|
||||
|
||||
void
|
||||
VCMQmSelect::ResetQM()
|
||||
{
|
||||
_motion.Reset();
|
||||
_spatial.Reset();
|
||||
_coherence.Reset();
|
||||
_stationaryMotion = 0;
|
||||
_aspectRatio = 1;
|
||||
_maxRateQM = 0;
|
||||
_imageType = 1;
|
||||
_userResolutionPref = 50; // Neutral
|
||||
_qm->Reset();
|
||||
return;
|
||||
}
|
||||
|
||||
void
|
||||
VCMQmSelect::ResetRates()
|
||||
{
|
||||
_sumEncodedBytes = 0;
|
||||
_sumTargetRate = 0;
|
||||
_sumIncomingFrameRate = 0;
|
||||
_sumFrameRateMM = 0;
|
||||
_sumSeqRateMM = 0;
|
||||
_frameCnt = 0;
|
||||
_frameCntDelta = 0;
|
||||
_lowBufferCnt = 0;
|
||||
_updateRateCnt = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
void
|
||||
VCMQmSelect::Reset()
|
||||
{
|
||||
_stateDecFactorSpatial = 1;
|
||||
_stateDecFactorTemp = 1;
|
||||
_bufferLevel = 0;
|
||||
_targetBitRate = 0;
|
||||
_incomingFrameRate = 0;
|
||||
_userFrameRate = 0;
|
||||
_perFrameBandwidth =0;
|
||||
ResetQM();
|
||||
ResetRates();
|
||||
return;
|
||||
}
|
||||
|
||||
//Initialize after reset of encoder
|
||||
WebRtc_Word32
|
||||
VCMQmSelect::Initialize(float bitRate, float userFrameRate, WebRtc_UWord32 width, WebRtc_UWord32 height)
|
||||
{
|
||||
if (userFrameRate == 0.0f || width == 0 || height == 0)
|
||||
{
|
||||
return VCM_PARAMETER_ERROR;
|
||||
}
|
||||
_targetBitRate = bitRate;
|
||||
_userFrameRate = userFrameRate;
|
||||
//Encoder width and height
|
||||
_width = width;
|
||||
_height = height;
|
||||
//Initial buffer level
|
||||
_bufferLevel = INIT_BUFFER_LEVEL * _targetBitRate;
|
||||
if ( _incomingFrameRate == 0 )
|
||||
{
|
||||
_perFrameBandwidth = _targetBitRate / _userFrameRate;
|
||||
_incomingFrameRate = _userFrameRate;
|
||||
}
|
||||
else
|
||||
{
|
||||
//Take average: this is due to delay in update of new frame rate in encoder:
|
||||
//userFrameRate is the new one, incomingFrameRate is the old one (based on previous ~ 1sec)
|
||||
_perFrameBandwidth = 0.5 *( _targetBitRate / _userFrameRate + _targetBitRate / _incomingFrameRate );
|
||||
}
|
||||
_init = true;
|
||||
|
||||
|
||||
return VCM_OK;
|
||||
}
|
||||
|
||||
WebRtc_Word32
|
||||
VCMQmSelect::SetPreferences(WebRtc_Word8 resolPref)
|
||||
{
|
||||
// Preference setting for temporal over spatial resolution
|
||||
// 100 means temporal, 0 means spatial, 50 is neutral (we decide)
|
||||
_userResolutionPref = resolPref;
|
||||
|
||||
return VCM_OK;
|
||||
}
|
||||
|
||||
//Update after every encoded frame
|
||||
void
|
||||
VCMQmSelect::UpdateEncodedSize(WebRtc_Word64 encodedSize, FrameType encodedFrameType)
|
||||
{
|
||||
//Update encoded size;
|
||||
_sumEncodedBytes += encodedSize;
|
||||
_frameCnt++;
|
||||
|
||||
//Convert to Kbps
|
||||
float encodedSizeKbits = (float)((encodedSize * 8.0) / 1000.0);
|
||||
|
||||
//Update the buffer level: per_frame_BW is updated when encoder is updated, every ~1sec
|
||||
_bufferLevel += _perFrameBandwidth - encodedSizeKbits;
|
||||
|
||||
const bool deltaFrame = (encodedFrameType != kVideoFrameKey &&
|
||||
encodedFrameType != kVideoFrameGolden);
|
||||
|
||||
//Sum the frame mismatch:
|
||||
//Mismatch here is based on difference of actual encoded frame size and per-frame bandwidth, for delta frames
|
||||
//This is a much stronger condition on rate mismatch than sumSeqRateMM
|
||||
// Note: not used in this version
|
||||
/*
|
||||
if (deltaFrame)
|
||||
{
|
||||
_frameCntDelta++;
|
||||
if (encodedSizeKbits > 0)
|
||||
_sumFrameRateMM += (float) (fabs(encodedSizeKbits - _perFrameBandwidth) / encodedSizeKbits);
|
||||
}
|
||||
*/
|
||||
|
||||
//Counter for occurrences of low buffer level
|
||||
if (_bufferLevel <= PERC_BUFFER_THR * INIT_BUFFER_LEVEL * _targetBitRate)
|
||||
{
|
||||
_lowBufferCnt++;
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
//Update after SetTargetRates in MediaOpt (every ~1sec)
|
||||
void
|
||||
VCMQmSelect::UpdateRates(float targetBitRate, float avgSentBitRate, float incomingFrameRate)
|
||||
{
|
||||
|
||||
//Sum the target bitrate and incoming frame rate: these values are the encoder rates (from previous ~1sec),
|
||||
//i.e, before the update for next ~1sec
|
||||
_sumTargetRate += _targetBitRate;
|
||||
_sumIncomingFrameRate += _incomingFrameRate;
|
||||
_updateRateCnt++;
|
||||
|
||||
//Convert to kbps
|
||||
float avgSentBitRatekbps = avgSentBitRate / 1000.0f;
|
||||
|
||||
//Sum the sequence rate mismatch:
|
||||
//Mismatch here is based on difference between target rate the encoder used (in previous ~1sec) and the average actual
|
||||
//encoding rate at current time
|
||||
if (fabs(_targetBitRate - avgSentBitRatekbps) < THRESH_SUM_MM && _targetBitRate > 0.0 )
|
||||
_sumSeqRateMM += (float) (fabs(_targetBitRate - avgSentBitRatekbps) / _targetBitRate );
|
||||
|
||||
//Update QM with the current new target and frame rate: these values are ones the encoder will use for the current/next ~1sec
|
||||
_targetBitRate = targetBitRate;
|
||||
_incomingFrameRate = incomingFrameRate;
|
||||
|
||||
//Update QM with an (average) encoder per_frame_bandwidth: this is the per_frame_bw for the next ~1sec
|
||||
_perFrameBandwidth = 0.0f;
|
||||
if (_incomingFrameRate > 0.0f)
|
||||
{
|
||||
_perFrameBandwidth = _targetBitRate / _incomingFrameRate;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
WebRtc_Word32
|
||||
VCMQmSelect::SelectQuality(const VideoContentMetrics* contentMetrics, VCMQualityMode** qm)
|
||||
{
|
||||
if (!_init)
|
||||
{
|
||||
return VCM_UNINITIALIZED;
|
||||
}
|
||||
if (contentMetrics == NULL)
|
||||
{
|
||||
Reset(); //default values
|
||||
*qm = _qm;
|
||||
return VCM_OK;
|
||||
}
|
||||
|
||||
//Default settings
|
||||
_qm->spatialWidthFact = 1;
|
||||
_qm->spatialHeightFact = 1;
|
||||
_qm->temporalFact = 1;
|
||||
|
||||
_contentMetrics = contentMetrics;
|
||||
|
||||
//Update native values
|
||||
_nativeWidth = _contentMetrics->nativeWidth;
|
||||
_nativeHeight = _contentMetrics->nativeHeight;
|
||||
_nativeFrameRate = _contentMetrics->nativeFrameRate;
|
||||
|
||||
//Aspect ratio: used for selection of 1x2,2x1,2x2
|
||||
_aspectRatio = (float)_width / (float)_height;
|
||||
|
||||
float avgTargetRate = 0.0f;
|
||||
float avgIncomingFrameRate = 0.0f;
|
||||
float ratioBufferLow = 0.0f;
|
||||
float rateMisMatch = 0.0f;
|
||||
if (_frameCnt > 0)
|
||||
{
|
||||
ratioBufferLow = (float)_lowBufferCnt / (float)_frameCnt;
|
||||
}
|
||||
if (_updateRateCnt > 0)
|
||||
{
|
||||
//use seq-rate mismatch for now
|
||||
rateMisMatch = (float)_sumSeqRateMM / (float)_updateRateCnt;
|
||||
//rateMisMatch = (float)_sumFrameRateMM / (float)_frameCntDelta;
|
||||
|
||||
//average target and incoming frame rates
|
||||
avgTargetRate = (float)_sumTargetRate / (float)_updateRateCnt;
|
||||
avgIncomingFrameRate = (float)_sumIncomingFrameRate / (float)_updateRateCnt;
|
||||
}
|
||||
|
||||
//For qm selection below, may want to weight the average encoder rates with the current (for next ~1sec) rate values
|
||||
//uniform average for now:
|
||||
float w1 = 0.5f;
|
||||
float w2 = 0.5f;
|
||||
avgTargetRate = w1 * avgTargetRate + w2 * _targetBitRate;
|
||||
avgIncomingFrameRate = w1 * avgIncomingFrameRate + w2 * _incomingFrameRate;
|
||||
|
||||
//Set the maximum transitional rate and image type: for up-sampled spatial dimensions
|
||||
//Needed to get the transRate for going back up in spatial resolution (only 2x2 allowed in this version)
|
||||
SetMaxRateForQM(2 * _width, 2 * _height);
|
||||
WebRtc_UWord8 imageType2 = _imageType;
|
||||
WebRtc_UWord32 maxRateQM2 = _maxRateQM;
|
||||
|
||||
//Set the maximum transitional rate and image type: for the input/encoder spatial dimensions
|
||||
SetMaxRateForQM(_width, _height);
|
||||
|
||||
//Compute metric features
|
||||
MotionNFD();
|
||||
Spatial();
|
||||
|
||||
//
|
||||
//Get transitional rate from table, based on image type and content class
|
||||
//
|
||||
|
||||
//Get image size class: map _imageType to 2 classes
|
||||
WebRtc_UWord8 imageClass = 1;
|
||||
if (_imageType <= 3) imageClass = 0;
|
||||
|
||||
WebRtc_UWord8 contentClass = 3 * _motion.level + _spatial.level;
|
||||
WebRtc_UWord8 tableIndex = imageClass * 9 + contentClass;
|
||||
float scaleTransRate = kScaleTransRateQm[tableIndex];
|
||||
|
||||
// for transRate for going back up spatially
|
||||
WebRtc_UWord8 imageClass2 = 1;
|
||||
if (imageType2 <= 3) imageClass2 = 0;
|
||||
WebRtc_UWord8 tableIndex2 = imageClass2 * 9 + contentClass;
|
||||
float scaleTransRate2 = kScaleTransRateQm[tableIndex2];
|
||||
//
|
||||
|
||||
WebRtc_UWord32 estimatedTransRateDown = (WebRtc_UWord32) (_incomingFrameRate * scaleTransRate * _maxRateQM / 30);
|
||||
WebRtc_UWord32 estimatedTransRateUpT = (WebRtc_UWord32) (TRANS_RATE_SCALE_UP_TEMP * 2 * _incomingFrameRate * scaleTransRate * _maxRateQM / 30);
|
||||
WebRtc_UWord32 estimatedTransRateUpS = (WebRtc_UWord32) (TRANS_RATE_SCALE_UP_SPATIAL * _incomingFrameRate * scaleTransRate2 * maxRateQM2 / 30);
|
||||
|
||||
//
|
||||
//done with transitional rate
|
||||
//
|
||||
|
||||
WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideo, -1,
|
||||
"Content Metrics: Motion = %d , Spatial = %d, Est. Trans. BR = %d",
|
||||
_motion.level, _spatial.level, estimatedTransRateDown);
|
||||
|
||||
|
||||
|
||||
//
|
||||
//CHECK FOR GOING BACK UP IN RESOLUTION
|
||||
//
|
||||
bool selectedUp = false;
|
||||
//Check if native has been spatially down-sampled
|
||||
if (_stateDecFactorSpatial > 1)
|
||||
{
|
||||
//check conditions on frame_skip and rate_mismatch
|
||||
if ( (avgTargetRate > estimatedTransRateUpS) &&
|
||||
(ratioBufferLow < MAX_BUFFER_LOW) && (rateMisMatch < MAX_RATE_MM) )
|
||||
{
|
||||
//width/height scaled back up: setting 0 indicates scaling back to native
|
||||
_qm->spatialHeightFact = 0;
|
||||
_qm->spatialWidthFact = 0;
|
||||
selectedUp = true;
|
||||
}
|
||||
}
|
||||
//Check if native has been temporally down-sampled
|
||||
if (_stateDecFactorTemp > 1)
|
||||
{
|
||||
if ( (avgTargetRate > estimatedTransRateUpT) &&
|
||||
(ratioBufferLow < MAX_BUFFER_LOW) && (rateMisMatch < MAX_RATE_MM) )
|
||||
{
|
||||
//temporal scale back up: setting 0 indicates scaling back to native
|
||||
_qm->temporalFact = 0;
|
||||
selectedUp = true;
|
||||
}
|
||||
}
|
||||
|
||||
//leave QM if we selected to go back up in either spatial or temporal resolution
|
||||
if (selectedUp == true)
|
||||
{
|
||||
//Update down-sampling state
|
||||
//Note: only temp reduction by 2 is allowed
|
||||
if (_qm->temporalFact == 0)
|
||||
{
|
||||
_stateDecFactorTemp = _stateDecFactorTemp / 2;
|
||||
}
|
||||
//Update down-sampling state
|
||||
//Note: only spatial reduction by 2x2 is allowed
|
||||
if (_qm->spatialHeightFact == 0 && _qm->spatialWidthFact == 0 )
|
||||
{
|
||||
_stateDecFactorSpatial = _stateDecFactorSpatial / 4;
|
||||
}
|
||||
*qm = _qm;
|
||||
return VCM_OK;
|
||||
}
|
||||
|
||||
//
|
||||
//done with checking for going back up
|
||||
//
|
||||
|
||||
//
|
||||
//CHECK FOR RESOLUTION REDUCTION
|
||||
//
|
||||
|
||||
//ST QM extraction if:
|
||||
// (1) target rate is lower than transitional rate (with safety margin), or
|
||||
// (2) frame skip is larger than threshold, or
|
||||
// (3) rate mismatch is larger than threshold
|
||||
|
||||
if ( (avgTargetRate < estimatedTransRateDown ) || (ratioBufferLow > MAX_BUFFER_LOW)
|
||||
|| (rateMisMatch > MAX_RATE_MM) )
|
||||
{
|
||||
|
||||
WebRtc_UWord8 spatialFact = 1;
|
||||
WebRtc_UWord8 tempFact = 1;
|
||||
|
||||
//Get the Action:
|
||||
//Note: only consider spatial by 2x2 OR temporal reduction by 2 in this version
|
||||
if (_motion.level == kLow && _spatial.level == kLow)
|
||||
{
|
||||
spatialFact = 1;
|
||||
tempFact = 1;
|
||||
}
|
||||
else if (_motion.level == kLow && _spatial.level == kHigh)
|
||||
{
|
||||
spatialFact = 1;
|
||||
tempFact = 2;
|
||||
}
|
||||
else if (_motion.level == kLow && _spatial.level == kDefault)
|
||||
{
|
||||
spatialFact = 1;
|
||||
tempFact = 2;
|
||||
}
|
||||
else if (_motion.level == kHigh && _spatial.level == kLow)
|
||||
{
|
||||
spatialFact = 4;
|
||||
tempFact = 1;
|
||||
}
|
||||
else if (_motion.level == kHigh && _spatial.level == kHigh)
|
||||
{
|
||||
spatialFact = 1;
|
||||
tempFact = 2;
|
||||
}
|
||||
else if (_motion.level == kHigh && _spatial.level == kDefault)
|
||||
{
|
||||
spatialFact = 4;
|
||||
tempFact = 1;
|
||||
}
|
||||
else if (_motion.level == kDefault && _spatial.level == kLow)
|
||||
{
|
||||
spatialFact = 4;
|
||||
tempFact = 1;
|
||||
}
|
||||
else if (_motion.level == kDefault && _spatial.level == kHigh)
|
||||
{
|
||||
spatialFact = 1;
|
||||
tempFact = 2;
|
||||
}
|
||||
else if (_motion.level == kDefault && _spatial.level == kDefault)
|
||||
{
|
||||
spatialFact = 1;
|
||||
tempFact = 1;
|
||||
}
|
||||
//
|
||||
switch(spatialFact)
|
||||
{
|
||||
case 4:
|
||||
_qm->spatialWidthFact = 2;
|
||||
_qm->spatialHeightFact = 2;
|
||||
break;
|
||||
case 2:
|
||||
//default is 1x2 (H)
|
||||
_qm->spatialWidthFact = 2;
|
||||
_qm->spatialHeightFact = 1;
|
||||
//Select 1x2,2x1, or back to 2x2: depends on prediction errors, aspect ratio, and horizontalness of motion
|
||||
//Note: directional selection not used in this version
|
||||
//SelectSpatialDirectionMode((float) estimatedTransRateDown);
|
||||
break;
|
||||
default:
|
||||
_qm->spatialWidthFact = 1;
|
||||
_qm->spatialHeightFact = 1;
|
||||
break;
|
||||
}
|
||||
_qm->temporalFact = tempFact;
|
||||
|
||||
//Sanity check on ST QM selection: override the settings for too small image size and frame rate
|
||||
//Also check limit the current down-sampling state
|
||||
|
||||
//No spatial sampling if image size is too small (QCIF)
|
||||
if ( (_width * _height) <= MIN_IMAGE_SIZE || _stateDecFactorSpatial >= MAX_SPATIAL_DOWN_FACT)
|
||||
{
|
||||
_qm->spatialWidthFact = 1;
|
||||
_qm->spatialHeightFact = 1;
|
||||
}
|
||||
|
||||
//No frame rate reduction below some point: use the (average) incoming frame rate
|
||||
if ( avgIncomingFrameRate <= MIN_FRAME_RATE_QM || _stateDecFactorTemp >= MAX_TEMP_DOWN_FACT)
|
||||
{
|
||||
_qm->temporalFact = 1;
|
||||
}
|
||||
|
||||
//No down-sampling if current spatial-temporal downsampling state is above threshold
|
||||
if (_stateDecFactorTemp * _stateDecFactorSpatial >= MAX_SPATIAL_TEMP_DOWN_FACT)
|
||||
{
|
||||
_qm->spatialWidthFact = 1;
|
||||
_qm->spatialHeightFact = 1;
|
||||
_qm->temporalFact = 1;
|
||||
}
|
||||
//
|
||||
//done with sanity checks on ST QM selection
|
||||
//
|
||||
|
||||
//Note: to disable spatial down-sampling
|
||||
// _qm->spatialWidthFact = 1;
|
||||
// _qm->spatialHeightFact = 1;
|
||||
|
||||
//Update down-sampling states
|
||||
_stateDecFactorSpatial = _stateDecFactorSpatial * _qm->spatialWidthFact * _qm->spatialHeightFact;
|
||||
_stateDecFactorTemp = _stateDecFactorTemp * _qm->temporalFact;
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
*qm = _qm;
|
||||
return VCM_OK;
|
||||
}
|
||||
// done with checking for resolution reduction
|
||||
|
||||
*qm = _qm;
|
||||
return VCM_OK;
|
||||
|
||||
|
||||
}
|
||||
|
||||
WebRtc_Word32
|
||||
VCMQmSelect::SelectSpatialDirectionMode(float transRate)
|
||||
{
|
||||
//Default is 1x2 (H)
|
||||
|
||||
//For bit rates well below transitional rate, we select 2x2
|
||||
if ( _targetBitRate < transRate * RATE_RED_SPATIAL_2X2 )
|
||||
{
|
||||
_qm->spatialWidthFact = 2;
|
||||
_qm->spatialHeightFact = 2;
|
||||
return VCM_OK;
|
||||
}
|
||||
|
||||
//Otherwise check prediction errors, aspect ratio, horizonalness of motion
|
||||
|
||||
float spatialErr = _contentMetrics->spatialPredErr;
|
||||
float spatialErrH = _contentMetrics->spatialPredErrH;
|
||||
float spatialErrV = _contentMetrics->spatialPredErrV;
|
||||
|
||||
//favor 1x2 if aspect_ratio is 16:9
|
||||
if (_aspectRatio >= 16.0f / 9.0f )
|
||||
{
|
||||
//check if 1x2 has lowest prediction error
|
||||
if (spatialErrH < spatialErr && spatialErrH < spatialErrV)
|
||||
{
|
||||
return VCM_OK;
|
||||
}
|
||||
}
|
||||
|
||||
//check for 2x2 selection: favor 2x2 over 1x2 and 2x1
|
||||
if (spatialErr < spatialErrH * (1.0f + SPATIAL_ERR_2X2_VS_H) &&
|
||||
spatialErr < spatialErrV * (1.0f + SPATIAL_ERR_2X2_VS_V))
|
||||
{
|
||||
_qm->spatialWidthFact = 2;
|
||||
_qm->spatialHeightFact = 2;
|
||||
return VCM_OK;
|
||||
}
|
||||
|
||||
//check for 2x1 selection:
|
||||
if (spatialErrV < spatialErrH * (1.0f - SPATIAL_ERR_V_VS_H) &&
|
||||
spatialErrV < spatialErr * (1.0f - SPATIAL_ERR_2X2_VS_V))
|
||||
{
|
||||
_qm->spatialWidthFact = 1;
|
||||
_qm->spatialHeightFact = 2;
|
||||
return VCM_OK;
|
||||
}
|
||||
|
||||
return VCM_OK;
|
||||
}
|
||||
|
||||
void
|
||||
VCMQmSelect::Coherence()
|
||||
{
|
||||
float horizNZ = _contentMetrics->motionHorizontalness;
|
||||
float distortionNZ = _contentMetrics->motionClusterDistortion;
|
||||
|
||||
//Coherence measure: combine horizontalness with cluster distortion
|
||||
_coherence.value = COH_MAX;
|
||||
if (distortionNZ > 0.)
|
||||
{
|
||||
_coherence.value = horizNZ / distortionNZ;
|
||||
}
|
||||
_coherence.value = VCM_MIN(COH_MAX, _coherence.value);
|
||||
|
||||
if (_coherence.value < COHERENCE_THR)
|
||||
{
|
||||
_coherence.level = kLow;
|
||||
}
|
||||
else
|
||||
{
|
||||
_coherence.level = kHigh;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void
|
||||
VCMQmSelect::MotionNFD()
|
||||
{
|
||||
_motion.value = _contentMetrics->motionMagnitudeNZ;
|
||||
|
||||
// determine motion level
|
||||
if (_motion.value < LOW_MOTION_NFD)
|
||||
{
|
||||
_motion.level = kLow;
|
||||
}
|
||||
else if (_motion.value > HIGH_MOTION_NFD)
|
||||
{
|
||||
_motion.level = kHigh;
|
||||
}
|
||||
else
|
||||
{
|
||||
_motion.level = kDefault;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void
|
||||
VCMQmSelect::Motion()
|
||||
{
|
||||
|
||||
float sizeZeroMotion = _contentMetrics->sizeZeroMotion;
|
||||
float motionMagNZ = _contentMetrics->motionMagnitudeNZ;
|
||||
|
||||
//take product of size and magnitude with equal weight for now
|
||||
_motion.value = (1.0f - sizeZeroMotion) * motionMagNZ;
|
||||
|
||||
//stabilize: motionMagNZ could be large when only few motion blocks are non-zero
|
||||
_stationaryMotion = false;
|
||||
if (sizeZeroMotion > HIGH_ZERO_MOTION_SIZE)
|
||||
{
|
||||
_motion.value = 0.0f;
|
||||
_stationaryMotion = true;
|
||||
}
|
||||
// determine motion level
|
||||
if (_motion.value < LOW_MOTION)
|
||||
{
|
||||
_motion.level = kLow;
|
||||
}
|
||||
else if (_motion.value > HIGH_MOTION)
|
||||
{
|
||||
_motion.level = kHigh;
|
||||
}
|
||||
else
|
||||
{
|
||||
_motion.level = kDefault;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
VCMQmSelect::Spatial()
|
||||
{
|
||||
float spatialErr = _contentMetrics->spatialPredErr;
|
||||
float spatialErrH = _contentMetrics->spatialPredErrH;
|
||||
float spatialErrV = _contentMetrics->spatialPredErrV;
|
||||
//Spatial measure: take average of 3 prediction errors
|
||||
_spatial.value = (spatialErr + spatialErrH + spatialErrV) / 3.0f;
|
||||
|
||||
float scale = 1.0f;
|
||||
//Reduce thresholds for HD scenes
|
||||
if (_imageType > 3)
|
||||
{
|
||||
scale = (float)SCALE_TEXTURE_HD;
|
||||
}
|
||||
|
||||
if (_spatial.value > scale * HIGH_TEXTURE)
|
||||
{
|
||||
_spatial.level = kHigh;
|
||||
}
|
||||
else if (_spatial.value < scale * LOW_TEXTURE)
|
||||
{
|
||||
_spatial.level = kLow;
|
||||
}
|
||||
else
|
||||
{
|
||||
_spatial.level = kDefault;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
WebRtc_Word32
|
||||
VCMQmSelect::SetMaxRateForQM(WebRtc_UWord32 width, WebRtc_UWord32 height)
|
||||
{
|
||||
// Match image type
|
||||
WebRtc_UWord32 imageSize = width * height;
|
||||
|
||||
if (imageSize < kFrameSizeTh[0])
|
||||
{
|
||||
_imageType = 0;
|
||||
}
|
||||
else if (imageSize < kFrameSizeTh[1])
|
||||
{
|
||||
_imageType = 1;
|
||||
}
|
||||
else if (imageSize < kFrameSizeTh[2])
|
||||
{
|
||||
_imageType = 2;
|
||||
}
|
||||
else if (imageSize < kFrameSizeTh[3])
|
||||
{
|
||||
_imageType = 3;
|
||||
}
|
||||
else if (imageSize < kFrameSizeTh[4])
|
||||
{
|
||||
_imageType = 4;
|
||||
}
|
||||
else if (imageSize < kFrameSizeTh[5])
|
||||
{
|
||||
_imageType = 5;
|
||||
}
|
||||
else
|
||||
{
|
||||
_imageType = 6;
|
||||
}
|
||||
|
||||
// set max rate based on image size
|
||||
_maxRateQM = kMaxRateQm[_imageType];
|
||||
|
||||
return VCM_OK;
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user