Delete VP8 feedback mode.

webrtc/modules/video_coding/codecs/vp8/vp8_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.
  */
 
@@ skipping 116 matching lines @@
 }
 
 VP8Decoder* VP8Decoder::Create() {
   return new VP8DecoderImpl();
 }
 
 VP8EncoderImpl::VP8EncoderImpl()
     : encoded_complete_callback_(nullptr),
       inited_(false),
       timestamp_(0),
-      feedback_mode_(false),
       qp_max_(56),  // Setting for max quantizer.
       cpu_speed_default_(-6),
       number_of_cores_(0),
       rc_max_intra_target_(0),
       token_partitions_(VP8_ONE_TOKENPARTITION),
       down_scale_requested_(false),
       down_scale_bitrate_(0),
       use_gf_boost_(webrtc::field_trial::IsEnabled(kVp8GfBoostFieldTrial)),
       key_frame_request_(kMaxSimulcastStreams, false) {
   uint32_t seed = rtc::Time32();
@@ skipping 195 matching lines @@
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
 
   int num_temporal_layers =
       doing_simulcast ? inst->simulcastStream[0].numberOfTemporalLayers
                       : inst->VP8().numberOfTemporalLayers;
   RTC_DCHECK_GT(num_temporal_layers, 0);
 
   SetupTemporalLayers(number_of_streams, num_temporal_layers, *inst);
 
-  feedback_mode_ = inst->VP8().feedbackModeOn;
-
   number_of_cores_ = number_of_cores;
   timestamp_ = 0;
   codec_ = *inst;
 
   // Code expects simulcastStream resolutions to be correct, make sure they are
   // filled even when there are no simulcast layers.
   if (codec_.numberOfSimulcastStreams == 0) {
     codec_.simulcastStream[0].width = codec_.width;
     codec_.simulcastStream[0].height = codec_.height;
   }
@@ skipping 80 matching lines @@
   configurations_[0].rc_max_quantizer = qp_max_;
   configurations_[0].rc_undershoot_pct = 100;
   configurations_[0].rc_overshoot_pct = 15;
   configurations_[0].rc_buf_initial_sz = 500;
   configurations_[0].rc_buf_optimal_sz = 600;
   configurations_[0].rc_buf_sz = 1000;
 
   // Set the maximum target size of any key-frame.
   rc_max_intra_target_ = MaxIntraTarget(configurations_[0].rc_buf_optimal_sz);
 
-  if (feedback_mode_) {
-    // Disable periodic key frames if we get feedback from the decoder
-    // through SLI and RPSI.
-    configurations_[0].kf_mode = VPX_KF_DISABLED;
-  } else if (inst->VP8().keyFrameInterval > 0) {
+  if (inst->VP8().keyFrameInterval > 0) {
     configurations_[0].kf_mode = VPX_KF_AUTO;
     configurations_[0].kf_max_dist = inst->VP8().keyFrameInterval;
   } else {
     configurations_[0].kf_mode = VPX_KF_DISABLED;
   }
 
   // Allow the user to set the complexity for the base stream.
   switch (inst->VP8().complexity) {
     case kComplexityHigh:
       cpu_speed_[0] = -5;
@@ skipping 63 matching lines @@
     vpx_img_alloc(&raw_images_[i], VPX_IMG_FMT_I420,
                   inst->simulcastStream[stream_idx].width,
                   inst->simulcastStream[stream_idx].height, kVp832ByteAlign);
     SetStreamState(stream_bitrates[stream_idx] > 0, stream_idx);
     configurations_[i].rc_target_bitrate = stream_bitrates[stream_idx];
     temporal_layers_[stream_idx]->OnRatesUpdated(
         stream_bitrates[stream_idx], inst->maxBitrate, inst->maxFramerate);
     temporal_layers_[stream_idx]->UpdateConfiguration(&configurations_[i]);
   }
 
-  rps_.Init();
   return InitAndSetControlSettings();
 }
 
 int VP8EncoderImpl::SetCpuSpeed(int width, int height) {
 #if defined(WEBRTC_ARCH_ARM) || defined(WEBRTC_ARCH_ARM64) || defined(ANDROID)
   // On mobile platform, use a lower speed setting for lower resolutions for
   // CPUs with 4 or more cores.
   RTC_DCHECK_GT(number_of_cores_, 0);
   if (number_of_cores_ <= 3)
     return -12;
@@ skipping 209 matching lines @@
       const uint32_t forceKeyFrameIntraTh = 100;
       vpx_codec_control(&(encoders_[0]), VP8E_SET_MAX_INTRA_BITRATE_PCT,
                         forceKeyFrameIntraTh);
     }
     // Key frame request from caller.
     // Will update both golden and alt-ref.
     for (size_t i = 0; i < encoders_.size(); ++i) {
       flags[i] = VPX_EFLAG_FORCE_KF;
     }
     std::fill(key_frame_request_.begin(), key_frame_request_.end(), false);
-  } else if (codec_specific_info &&
-             codec_specific_info->codecType == kVideoCodecVP8) {
-    if (feedback_mode_) {
-      // Handle RPSI and SLI messages and set up the appropriate encode flags.
-      bool sendRefresh = false;
-      if (codec_specific_info->codecSpecific.VP8.hasReceivedRPSI) {
-        rps_.ReceivedRPSI(codec_specific_info->codecSpecific.VP8.pictureIdRPSI);
-      }
-      if (codec_specific_info->codecSpecific.VP8.hasReceivedSLI) {
-        sendRefresh = rps_.ReceivedSLI(frame.timestamp());
-      }
-      for (size_t i = 0; i < encoders_.size(); ++i) {
-        flags[i] = rps_.EncodeFlags(picture_id_[i], sendRefresh,
-                                    frame.timestamp());
-      }
-    } else {
-      if (codec_specific_info->codecSpecific.VP8.hasReceivedRPSI) {
-        // Is this our last key frame? If not ignore.
-        // |picture_id_| is defined per spatial stream/layer, so check that
-        // |RPSI| matches the last key frame from any of the spatial streams.
-        // If so, then all spatial streams for this encoding will predict from
-        // its long-term reference (last key frame).
-        int RPSI = codec_specific_info->codecSpecific.VP8.pictureIdRPSI;
-        for (size_t i = 0; i < encoders_.size(); ++i) {
-          if (last_key_frame_picture_id_[i] == RPSI) {
-            // Request for a long term reference frame.
-            // Note 1: overwrites any temporal settings.
-            // Note 2: VP8_EFLAG_NO_UPD_ENTROPY is not needed as that flag is
-            //         set by error_resilient mode.
-            for (size_t j = 0; j < encoders_.size(); ++j) {
-              flags[j] = VP8_EFLAG_NO_UPD_ARF;
-              flags[j] |= VP8_EFLAG_NO_REF_GF;
-              flags[j] |= VP8_EFLAG_NO_REF_LAST;
-            }
-            only_predict_from_key_frame = true;
-            break;
-          }
-        }
-      }
-    }
   }
+
   // Set the encoder frame flags and temporal layer_id for each spatial stream.
   // Note that |temporal_layers_| are defined starting from lowest resolution at
   // position 0 to highest resolution at position |encoders_.size() - 1|,
   // whereas |encoder_| is from highest to lowest resolution.
   size_t stream_idx = encoders_.size() - 1;
   for (size_t i = 0; i < encoders_.size(); ++i, --stream_idx) {
     // Allow the layers adapter to temporarily modify the configuration. This
     // change isn't stored in configurations_ so change will be discarded at
     // the next update.
     vpx_codec_enc_cfg_t temp_config;
@@ skipping 129 matching lines @@
           break;
         }
         default:
           break;
       }
       // End of frame
       if ((pkt->data.frame.flags & VPX_FRAME_IS_FRAGMENT) == 0) {
         // check if encoded frame is a key frame
         if (pkt->data.frame.flags & VPX_FRAME_IS_KEY) {
           encoded_images_[encoder_idx]._frameType = kVideoFrameKey;
-          rps_.EncodedKeyFrame(picture_id_[stream_idx]);
         }
         PopulateCodecSpecific(&codec_specific, *pkt, stream_idx,
                               input_image.timestamp(),
                               only_predicting_from_key_frame);
         break;
       }
     }
     encoded_images_[encoder_idx]._timeStamp = input_image.timestamp();
     encoded_images_[encoder_idx].capture_time_ms_ =
         input_image.render_time_ms();
@@ skipping 30 matching lines @@
 }
 
 VideoEncoder::ScalingSettings VP8EncoderImpl::GetScalingSettings() const {
   const bool enable_scaling = encoders_.size() == 1 &&
                               configurations_[0].rc_dropframe_thresh > 0 &&
                               codec_.VP8().automaticResizeOn;
   return VideoEncoder::ScalingSettings(enable_scaling);
 }
 
 int VP8EncoderImpl::SetChannelParameters(uint32_t packetLoss, int64_t rtt) {
-  rps_.SetRtt(rtt);
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int VP8EncoderImpl::RegisterEncodeCompleteCallback(
     EncodedImageCallback* callback) {
   encoded_complete_callback_ = callback;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 VP8DecoderImpl::VP8DecoderImpl()
     : buffer_pool_(false, 300 /* max_number_of_buffers*/),
       decode_complete_callback_(NULL),
       inited_(false),
-      feedback_mode_(false),
       decoder_(NULL),
       image_format_(VPX_IMG_FMT_NONE),
       ref_frame_(NULL),
       propagation_cnt_(-1),
       last_frame_width_(0),
       last_frame_height_(0),
       key_frame_required_(true),
       use_postproc_arm_(webrtc::field_trial::FindFullName(
                             kVp8PostProcArmFieldTrial) == "Enabled") {}
 
 VP8DecoderImpl::~VP8DecoderImpl() {
   inited_ = true;  // in order to do the actual release
   Release();
 }
 
 int VP8DecoderImpl::InitDecode(const VideoCodec* inst, int number_of_cores) {
   int ret_val = Release();
   if (ret_val < 0) {
     return ret_val;
   }
   if (decoder_ == NULL) {
     decoder_ = new vpx_codec_ctx_t;
     memset(decoder_, 0, sizeof(*decoder_));
   }
-  if (inst && inst->codecType == kVideoCodecVP8) {
-    feedback_mode_ = inst->VP8().feedbackModeOn;
-  }
   vpx_codec_dec_cfg_t cfg;
   // Setting number of threads to a constant value (1)
   cfg.threads = 1;
   cfg.h = cfg.w = 0;  // set after decode
 
   vpx_codec_flags_t flags = 0;
 #if defined(WEBRTC_ARCH_ARM) || defined(WEBRTC_ARCH_ARM64) || defined(ANDROID)
   if (use_postproc_arm_) {
     flags = VPX_CODEC_USE_POSTPROC;
   }
@@ skipping 68 matching lines @@
   if (key_frame_required_) {
     if (input_image._frameType != kVideoFrameKey)
       return WEBRTC_VIDEO_CODEC_ERROR;
     // We have a key frame - is it complete?
     if (input_image._completeFrame) {
       key_frame_required_ = false;
     } else {
       return WEBRTC_VIDEO_CODEC_ERROR;
     }
   }
-  // Restrict error propagation using key frame requests. Disabled when
-  // the feedback mode is enabled (RPS).
+  // Restrict error propagation using key frame requests.
   // Reset on a key frame refresh.
-  if (!feedback_mode_) {
-    if (input_image._frameType == kVideoFrameKey &&
-        input_image._completeFrame) {
+  if (input_image._frameType == kVideoFrameKey &&
+      input_image._completeFrame) {
       propagation_cnt_ = -1;
       // Start count on first loss.
-    } else if ((!input_image._completeFrame || missing_frames) &&
-               propagation_cnt_ == -1) {
-      propagation_cnt_ = 0;
-    }
-    if (propagation_cnt_ >= 0) {
-      propagation_cnt_++;
-    }
+  } else if ((!input_image._completeFrame || missing_frames) &&
+             propagation_cnt_ == -1) {
+    propagation_cnt_ = 0;
+  }
+  if (propagation_cnt_ >= 0) {
+    propagation_cnt_++;
   }
 
   vpx_codec_iter_t iter = NULL;
   vpx_image_t* img;
   int ret;
 
   // Check for missing frames.
   if (missing_frames) {
     // Call decoder with zero data length to signal missing frames.
     if (vpx_codec_decode(decoder_, NULL, 0, 0, VPX_DL_REALTIME)) {
@@ skipping 24 matching lines @@
   vpx_codec_err_t vpx_ret =
       vpx_codec_control(decoder_, VPXD_GET_LAST_QUANTIZER, &qp);
   RTC_DCHECK_EQ(vpx_ret, VPX_CODEC_OK);
   ret = ReturnFrame(img, input_image._timeStamp, input_image.ntp_time_ms_, qp);
   if (ret != 0) {
     // Reset to avoid requesting key frames too often.
     if (ret < 0 && propagation_cnt_ > 0)
       propagation_cnt_ = 0;
     return ret;
   }
-  if (feedback_mode_) {
-    // Whenever we receive an incomplete key frame all reference buffers will
-    // be corrupt. If that happens we must request new key frames until we
-    // decode a complete key frame.
-    if (input_image._frameType == kVideoFrameKey && !input_image._completeFrame)
-      return WEBRTC_VIDEO_CODEC_ERROR;
-    // Check for reference updates and last reference buffer corruption and
-    // signal successful reference propagation or frame corruption to the
-    // encoder.
-    int reference_updates = 0;
-    if (vpx_codec_control(decoder_, VP8D_GET_LAST_REF_UPDATES,
-                          &reference_updates)) {
-      // Reset to avoid requesting key frames too often.
-      if (propagation_cnt_ > 0) {
-        propagation_cnt_ = 0;
-      }
-      return WEBRTC_VIDEO_CODEC_ERROR;
-    }
-    int corrupted = 0;
-    if (vpx_codec_control(decoder_, VP8D_GET_FRAME_CORRUPTED, &corrupted)) {
-      // Reset to avoid requesting key frames too often.
-      if (propagation_cnt_ > 0)
-        propagation_cnt_ = 0;
-      return WEBRTC_VIDEO_CODEC_ERROR;
-    }
-    int16_t picture_id = -1;
-    if (codec_specific_info) {
-      picture_id = codec_specific_info->codecSpecific.VP8.pictureId;
-    }
-    if (picture_id > -1) {
-      if (((reference_updates & VP8_GOLD_FRAME) ||
-           (reference_updates & VP8_ALTR_FRAME)) &&
-          !corrupted) {
-        decode_complete_callback_->ReceivedDecodedReferenceFrame(picture_id);
-      }
-      decode_complete_callback_->ReceivedDecodedFrame(picture_id);
-    }
-    if (corrupted) {
-      // we can decode but with artifacts
-      return WEBRTC_VIDEO_CODEC_REQUEST_SLI;
-    }
-  }
   // Check Vs. threshold
   if (propagation_cnt_ > kVp8ErrorPropagationTh) {
     // Reset to avoid requesting key frames too often.
     propagation_cnt_ = 0;
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int VP8DecoderImpl::ReturnFrame(const vpx_image_t* img,
@@ skipping 70 matching lines @@
     return -1;
   }
   if (vpx_codec_control(copy->decoder_, VP8_SET_REFERENCE, ref_frame_) !=
       VPX_CODEC_OK) {
     return -1;
   }
   return 0;
 }
 
 }  // namespace webrtc