webrtc_m130/src/modules/video_coding/main/source/qm_select.h

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

#ifndef WEBRTC_MODULES_VIDEO_CODING_QM_SELECT_H_
#define WEBRTC_MODULES_VIDEO_CODING_QM_SELECT_H_

#include "common_types.h"
#include "typedefs.h"

/******************************************************/
/* Quality Modes: Resolution and Robustness settings  */
/******************************************************/

namespace webrtc {
struct VideoContentMetrics;

struct VCMResolutionScale {
  VCMResolutionScale()
      : spatialWidthFact(1),
        spatialHeightFact(1),
        temporalFact(1) {
  }
  uint8_t spatialWidthFact;
  uint8_t spatialHeightFact;
  uint8_t temporalFact;
};

enum LevelClass {
  kLow,
  kHigh,
  kDefault
};

struct VCMContFeature {
  VCMContFeature()
      : value(0.0f),
        level(kDefault) {
  }
  void Reset() {
    value = 0.0f;
    level = kDefault;
  }
  float value;
  LevelClass level;
};

enum ResolutionAction {
  kDownResolution,
  kUpResolution,
  kNoChangeResolution
};

enum EncoderState {
  kStableEncoding,    // Low rate mis-match, stable buffer levels.
  kStressedEncoding,  // Significant over-shooting of target rate,
                      // Buffer under-flow, etc.
  kEasyEncoding       // Significant under-shooting of target rate.
};

// QmMethod class: main class for resolution and robustness settings

class VCMQmMethod {
 public:
  VCMQmMethod();
  virtual ~VCMQmMethod();

  // Reset values
  void ResetQM();
  virtual void Reset() = 0;

  // Compute content class.
  uint8_t ComputeContentClass();

  // Update with the content metrics.
  void UpdateContent(const VideoContentMetrics* contentMetrics);

  // Compute spatial texture magnitude and level.
  // Spatial texture is a spatial prediction error measure.
  void ComputeSpatial();

  // Compute motion magnitude and level for NFD metric.
  // NFD is normalized frame difference (normalized by spatial variance).
  void ComputeMotionNFD();

  // Get the imageType (CIF, VGA, HD, etc) for the system width/height.
  uint8_t GetImageType(uint16_t width, uint16_t height);

  // Get the frame rate level.
  LevelClass FrameRateLevel(float frame_rate);

 protected:
  // Content Data.
  const VideoContentMetrics* _contentMetrics;

  // Encoder frame sizes and native frame sizes.
  uint16_t _width;
  uint16_t _height;
  uint16_t _nativeWidth;
  uint16_t _nativeHeight;
  float _aspectRatio;
  // Image type and frame rate leve, for the current encoder resolution.
  uint8_t _imageType;
  LevelClass _frameRateLevel;
  // Content class data.
  VCMContFeature _motion;
  VCMContFeature _spatial;
  uint8_t _contentClass;
  bool _init;
};

// Resolution settings class

class VCMQmResolution : public VCMQmMethod {
 public:
  VCMQmResolution();
  virtual ~VCMQmResolution();

  // Reset all quantities.
  virtual void Reset();

  // Reset rate quantities and counters after every SelectResolution() call.
  void ResetRates();

  // Reset down-sampling state.
  void ResetDownSamplingState();

  // Get the encoder state.
  EncoderState GetEncoderState();

  // Initialize after SetEncodingData in media_opt.
  int Initialize(float bitRate, float userFrameRate,
                 uint16_t width, uint16_t height);

  // Update the encoder frame size.
  void UpdateCodecFrameSize(uint16_t width, uint16_t height);

  // Update with actual bit rate (size of the latest encoded frame)
  // and frame type, after every encoded frame.
  void UpdateEncodedSize(int encodedSize,
                         FrameType encodedFrameType);

  // Update with new target bitrate, actual encoder sent rate, frame_rate,
  // loss rate: every ~1 sec from SetTargetRates in media_opt.
  void UpdateRates(float targetBitRate, float encoderSentRate,
                   float incomingFrameRate, uint8_t packetLoss);

  // Extract ST (spatio-temporal) resolution action.
  // Inputs: qm: Reference to the quality modes pointer.
  // Output: the spatial and/or temporal scale change.
  int SelectResolution(VCMResolutionScale** qm);

  // Compute rates for the selection of down-sampling action.
  void ComputeRatesForSelection();

  // Compute the encoder state.
  void ComputeEncoderState();

  // Return true if the action is to go back up in resolution.
  bool GoingUpResolution();

  // Return true if the action is to go down in resolution.
  bool GoingDownResolution();

  // Check the condition for going up in resolution by the scale factors:
  // |facWidth|, |facHeight|, |facTemp|.
  // |scaleFac| is a scale factor for the transition rate.
  bool ConditionForGoingUp(uint8_t facWidth, uint8_t facHeight,
                           uint8_t facTemp,
                           float scaleFac);

  // Get the bitrate threshold for the resolution action.
  // The case |facWidth|=|facHeight|=|facTemp|==1 is for down-sampling action.
  // |scaleFac| is a scale factor for the transition rate.
  float GetTransitionRate(uint8_t facWidth, uint8_t facHeight,
                          uint8_t facTemp, float scaleFac);

  // Update the downsampling state.
  void UpdateDownsamplingState(ResolutionAction action);

  void AdjustAction();

  // Select the directional (1x2 or 2x1) spatial down-sampling action.
  void SelectSpatialDirectionMode(float transRate);

 private:
  VCMResolutionScale* _qm;
  // Encoder rate control parameters.
  float _targetBitRate;
  float _userFrameRate;
  float _incomingFrameRate;
  float _perFrameBandwidth;
  float _bufferLevel;

  // Data accumulated every ~1sec from MediaOpt.
  float _sumTargetRate;
  float _sumIncomingFrameRate;
  float _sumRateMM;
  float _sumRateMMSgn;
  float  _sumPacketLoss;
  // Counters.
  uint32_t _frameCnt;
  uint32_t _frameCntDelta;
  uint32_t _updateRateCnt;
  uint32_t _lowBufferCnt;

  // Resolution state parameters.
  uint8_t _stateDecFactorSpatial;
  uint8_t _stateDecFactorTemp;

  // Quantities used for selection.
  float _avgTargetRate;
  float _avgIncomingFrameRate;
  float _avgRatioBufferLow;
  float _avgRateMisMatch;
  float _avgRateMisMatchSgn;
  float _avgPacketLoss;
  EncoderState _encoderState;
};

// Robustness settings class.

class VCMQmRobustness : public VCMQmMethod {
 public:
  VCMQmRobustness();
  ~VCMQmRobustness();

  virtual void Reset();

  // Adjust FEC rate based on content: every ~1 sec from SetTargetRates.
  // Returns an adjustment factor.
  float AdjustFecFactor(uint8_t codeRateDelta,
                        float totalRate,
                        float frameRate,
                        uint32_t rttTime,
                        uint8_t packetLoss);

  // Set the UEP protection on/off.
  bool SetUepProtection(uint8_t codeRateDelta,
                        float totalRate,
                        uint8_t packetLoss,
                        bool frameType);

 private:
  // Previous state of network parameters.
  float _prevTotalRate;
  uint32_t _prevRttTime;
  uint8_t _prevPacketLoss;
  uint8_t _prevCodeRateDelta;
};
}   // namespace webrtc
#endif  // WEBRTC_MODULES_VIDEO_CODING_QM_SELECT_H_