Delete support for receiving RTCP RPSI and SLI messages.

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 306 matching lines @@
   // allow zero to represent an unspecified maxBitRate
   if (inst->maxBitrate > 0 && inst->startBitrate > inst->maxBitrate) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   if (inst->width <= 1 || inst->height <= 1) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   if (number_of_cores < 1) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
-  if (inst->VP8().feedbackModeOn && inst->numberOfSimulcastStreams > 1) {
-    return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
-  }
   if (inst->VP8().automaticResizeOn && inst->numberOfSimulcastStreams > 1) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   int retVal = Release();
   if (retVal < 0) {
     return retVal;
   }
 
   int number_of_streams = NumberOfStreams(*inst);
   bool doing_simulcast = (number_of_streams > 1);
@@ skipping 396 matching lines @@
   }
   if (!send_key_frame && frame_types) {
     for (size_t i = 0; i < frame_types->size() && i < send_stream_.size();
          ++i) {
       if ((*frame_types)[i] == kVideoFrameKey && send_stream_[i]) {
         send_key_frame = true;
         break;
       }
     }
   }
-  // The flag modification below (due to forced key frame, RPS, etc.,) for now
-  // will be the same for all encoders/spatial layers.
-  // TODO(marpan/holmer): Allow for key frame request to be set per encoder.
-  bool only_predict_from_key_frame = false;
   if (send_key_frame) {
     // Adapt the size of the key frame when in screenshare with 1 temporal
     // layer.
     if (encoders_.size() == 1 && codec_.mode == kScreensharing &&
         codec_.VP8()->numberOfTemporalLayers <= 1) {
       const uint32_t forceKeyFrameIntraTh = 100;
       vpx_codec_control(&(encoders_[0]), VP8E_SET_MAX_INTRA_BITRATE_PCT,
                         forceKeyFrameIntraTh);
     }
     // Key frame request from caller.
@@ skipping 38 matching lines @@
                                duration, 0, VPX_DL_REALTIME);
   // Reset specific intra frame thresholds, following the key frame.
   if (send_key_frame) {
     vpx_codec_control(&(encoders_[0]), VP8E_SET_MAX_INTRA_BITRATE_PCT,
                       rc_max_intra_target_);
   }
   if (error)
     return WEBRTC_VIDEO_CODEC_ERROR;
   timestamp_ += duration;
   // Examines frame timestamps only.
-  return GetEncodedPartitions(frame, only_predict_from_key_frame);
+  return GetEncodedPartitions(frame);
 }
 
 // TODO(pbos): Make sure this works for properly for >1 encoders.
 int VP8EncoderImpl::UpdateCodecFrameSize(int width, int height) {
   codec_.width = width;
   codec_.height = height;
   if (codec_.numberOfSimulcastStreams <= 1) {
     // For now scaling is only used for single-layer streams.
     codec_.simulcastStream[0].width = width;
     codec_.simulcastStream[0].height = height;
@@ skipping 14 matching lines @@
   if (vpx_codec_enc_config_set(&encoders_[0], &configurations_[0])) {
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 void VP8EncoderImpl::PopulateCodecSpecific(
     CodecSpecificInfo* codec_specific,
     const vpx_codec_cx_pkt_t& pkt,
     int stream_idx,
-    uint32_t timestamp,
-    bool only_predicting_from_key_frame) {
+    uint32_t timestamp) {
   assert(codec_specific != NULL);
   codec_specific->codecType = kVideoCodecVP8;
   codec_specific->codec_name = ImplementationName();
   CodecSpecificInfoVP8* vp8Info = &(codec_specific->codecSpecific.VP8);
   vp8Info->pictureId = picture_id_[stream_idx];
   if (pkt.data.frame.flags & VPX_FRAME_IS_KEY) {
     last_key_frame_picture_id_[stream_idx] = picture_id_[stream_idx];
   }
   vp8Info->simulcastIdx = stream_idx;
   vp8Info->keyIdx = kNoKeyIdx;  // TODO(hlundin) populate this
   vp8Info->nonReference =
       (pkt.data.frame.flags & VPX_FRAME_IS_DROPPABLE) ? true : false;
-  bool base_layer_sync_point = (pkt.data.frame.flags & VPX_FRAME_IS_KEY) ||
-                               only_predicting_from_key_frame;
+  bool base_layer_sync_point = pkt.data.frame.flags & VPX_FRAME_IS_KEY;
   temporal_layers_[stream_idx]->PopulateCodecSpecific(base_layer_sync_point,
                                                       vp8Info, timestamp);
   // Prepare next.
   picture_id_[stream_idx] = (picture_id_[stream_idx] + 1) & 0x7FFF;
 }
 
-int VP8EncoderImpl::GetEncodedPartitions(const VideoFrame& input_image,
-                                         bool only_predicting_from_key_frame) {
+int VP8EncoderImpl::GetEncodedPartitions(const VideoFrame& input_image) {
   int bw_resolutions_disabled =
       (encoders_.size() > 1) ? NumStreamsDisabled(send_stream_) : -1;
 
   int stream_idx = static_cast<int>(encoders_.size()) - 1;
   int result = WEBRTC_VIDEO_CODEC_OK;
   for (size_t encoder_idx = 0; encoder_idx < encoders_.size();
        ++encoder_idx, --stream_idx) {
     vpx_codec_iter_t iter = NULL;
     int part_idx = 0;
     encoded_images_[encoder_idx]._length = 0;
@@ skipping 31 matching lines @@
         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;
         }
         PopulateCodecSpecific(&codec_specific, *pkt, stream_idx,
-                              input_image.timestamp(),
-                              only_predicting_from_key_frame);
+                              input_image.timestamp());
         break;
       }
     }
     encoded_images_[encoder_idx]._timeStamp = input_image.timestamp();
     encoded_images_[encoder_idx].capture_time_ms_ =
         input_image.render_time_ms();
     encoded_images_[encoder_idx].rotation_ = input_image.rotation();
 
     int qp = -1;
     vpx_codec_control(&encoders_[encoder_idx], VP8E_GET_LAST_QUANTIZER_64, &qp);
@@ skipping 155 matching lines @@
     if (input_image._completeFrame) {
       key_frame_required_ = false;
     } else {
       return WEBRTC_VIDEO_CODEC_ERROR;
     }
   }
   // Restrict error propagation using key frame requests.
   // Reset on a key frame refresh.
   if (input_image._frameType == kVideoFrameKey &&
       input_image._completeFrame) {
-      propagation_cnt_ = -1;
-      // Start count on first loss.
+    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_++;
   }
 
   vpx_codec_iter_t iter = NULL;
   vpx_image_t* img;
@@ skipping 120 matching lines @@
     return -1;
   }
   if (vpx_codec_control(copy->decoder_, VP8_SET_REFERENCE, ref_frame_) !=
       VPX_CODEC_OK) {
     return -1;
   }
   return 0;
 }
 
 }  // namespace webrtc