Remove dead code in vp8_impl files.

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 23 matching lines @@
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 
 namespace webrtc {
 namespace {
 
 const char kVp8PostProcArmFieldTrial[] = "WebRTC-VP8-Postproc-Arm";
 const char kVp8GfBoostFieldTrial[] = "WebRTC-VP8-GfBoost";
 
+const int kTokenPartitions = VP8_ONE_TOKENPARTITION;
 enum { kVp8ErrorPropagationTh = 30 };
 enum { kVp832ByteAlign = 32 };
 
 // VP8 denoiser states.
 enum denoiserState {
   kDenoiserOff,
   kDenoiserOnYOnly,
   kDenoiserOnYUV,
   kDenoiserOnYUVAggressive,
   // Adaptive mode defaults to kDenoiserOnYUV on key frame, but may switch
@@ skipping 70 matching lines @@
 
 VP8Encoder* VP8Encoder::Create() {
   return new VP8EncoderImpl();
 }
 
 VP8Decoder* VP8Decoder::Create() {
   return new VP8DecoderImpl();
 }
 
 VP8EncoderImpl::VP8EncoderImpl()
-    : encoded_complete_callback_(nullptr),
+    : use_gf_boost_(webrtc::field_trial::IsEnabled(kVp8GfBoostFieldTrial)),
+      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();
   srand(seed);
 
   picture_id_.reserve(kMaxSimulcastStreams);
   last_key_frame_picture_id_.reserve(kMaxSimulcastStreams);
   temporal_layers_.reserve(kMaxSimulcastStreams);
   raw_images_.reserve(kMaxSimulcastStreams);
   encoded_images_.reserve(kMaxSimulcastStreams);
   send_stream_.reserve(kMaxSimulcastStreams);
-  cpu_speed_.assign(kMaxSimulcastStreams, -6);  // Set default to -6.
+  cpu_speed_.assign(kMaxSimulcastStreams, cpu_speed_default_);
   encoders_.reserve(kMaxSimulcastStreams);
   configurations_.reserve(kMaxSimulcastStreams);
   downsampling_factors_.reserve(kMaxSimulcastStreams);
 }
 
 VP8EncoderImpl::~VP8EncoderImpl() {
   Release();
 }
 
 int VP8EncoderImpl::Release() {
@@ skipping 47 matching lines @@
 
   // At this point, bitrate allocation should already match codec settings.
   if (codec_.maxBitrate > 0)
     RTC_DCHECK_LE(bitrate.get_sum_kbps(), codec_.maxBitrate);
   RTC_DCHECK_GE(bitrate.get_sum_kbps(), codec_.minBitrate);
   if (codec_.numberOfSimulcastStreams > 0)
     RTC_DCHECK_GE(bitrate.get_sum_kbps(), codec_.simulcastStream[0].minBitrate);
 
   codec_.maxFramerate = new_framerate;
 
-  if (encoders_.size() == 1) {
-    // 1:1.
-    // Calculate a rough limit for when to trigger a potental down scale.
-    uint32_t k_pixels_per_frame = codec_.width * codec_.height / 1000;
-    // TODO(pwestin): we currently lack CAMA, this is a temporary fix to work
-    // around the current limitations.
-    // Only trigger keyframes if we are allowed to scale down.
-    if (configurations_[0].rc_resize_allowed) {
-      if (!down_scale_requested_) {
-        if (k_pixels_per_frame > bitrate.get_sum_kbps()) {
-          down_scale_requested_ = true;
-          down_scale_bitrate_ = bitrate.get_sum_kbps();
-          key_frame_request_[0] = true;
-        }
-      } else {
-        if (bitrate.get_sum_kbps() > (2 * down_scale_bitrate_) ||
-            bitrate.get_sum_kbps() < (down_scale_bitrate_ / 2)) {
-          down_scale_requested_ = false;
-        }
-      }
-    }
-  } else {
+  if (encoders_.size() > 1) {
     // If we have more than 1 stream, reduce the qp_max for the low resolution
     // stream if frame rate is not too low. The trade-off with lower qp_max is
     // possibly more dropped frames, so we only do this if the frame rate is
     // above some threshold (base temporal layer is down to 1/4 for 3 layers).
     // We may want to condition this on bitrate later.
     if (new_framerate > 20) {
       configurations_[encoders_.size() - 1].rc_max_quantizer = 45;
     } else {
       // Go back to default value set in InitEncode.
       configurations_[encoders_.size() - 1].rc_max_quantizer = qp_max_;
@@ skipping 62 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);
 
   if (doing_simulcast && !ValidSimulcastResolutions(*inst, number_of_streams)) {
     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 57 matching lines @@
       // drop support for libvpx 9.6.0.
       break;
     case kResilientFrames:
       return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;  // Not supported
   }
 
   // rate control settings
   configurations_[0].rc_dropframe_thresh = inst->VP8().frameDroppingOn ? 30 : 0;
   configurations_[0].rc_end_usage = VPX_CBR;
   configurations_[0].g_pass = VPX_RC_ONE_PASS;
-  // TODO(hellner): investigate why the following two lines produce
-  // automaticResizeOn value of 3 when running
-  // WebRtcVideoMediaChannelTest.GetStatsMultipleSendStreams inside the talk
-  // framework.
-  // configurations_[0].rc_resize_allowed =
-  //    inst->codecSpecific.VP8.automaticResizeOn ? 1 : 0;
+  // Handle resizing outside of libvpx.
   configurations_[0].rc_resize_allowed = 0;
-  // Handle resizing outside of libvpx when doing single-stream.
-  if (inst->VP8().automaticResizeOn && number_of_streams > 1) {
-    configurations_[0].rc_resize_allowed = 1;
-  }
   configurations_[0].rc_min_quantizer = 2;
   if (inst->qpMax >= configurations_[0].rc_min_quantizer) {
     qp_max_ = inst->qpMax;
   }
   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 165 matching lines @@
     vpx_codec_control(
         &encoders_[1], VP8E_SET_NOISE_SENSITIVITY,
         codec_.VP8()->denoisingOn ? denoiser_state : kDenoiserOff);
   }
   for (size_t i = 0; i < encoders_.size(); ++i) {
     // Allow more screen content to be detected as static.
     vpx_codec_control(&(encoders_[i]), VP8E_SET_STATIC_THRESHOLD,
                       codec_.mode == kScreensharing ? 300 : 1);
     vpx_codec_control(&(encoders_[i]), VP8E_SET_CPUUSED, cpu_speed_[i]);
     vpx_codec_control(&(encoders_[i]), VP8E_SET_TOKEN_PARTITIONS,
-                      static_cast<vp8e_token_partitions>(token_partitions_));
+                      static_cast<vp8e_token_partitions>(kTokenPartitions));
     vpx_codec_control(&(encoders_[i]), VP8E_SET_MAX_INTRA_BITRATE_PCT,
                       rc_max_intra_target_);
     // VP8E_SET_SCREEN_CONTENT_MODE 2 = screen content with more aggressive
     // rate control (drop frames on large target bitrate overshoot)
     vpx_codec_control(&(encoders_[i]), VP8E_SET_SCREEN_CONTENT_MODE,
                       codec_.mode == kScreensharing ? 2 : 0);
     // Apply boost on golden frames (has only effect when resilience is off).
     if (use_gf_boost_ && codec_.VP8()->resilience == kResilienceOff) {
       int gf_boost_percent;
       if (GetGfBoostPercentageFromFieldTrialGroup(&gf_boost_percent)) {
@@ skipping 109 matching lines @@
                         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());
-      }
+    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;

[nisse-webrtc, 2017/03/17 08:54:48]

What's the state of rpsi (and sli) support after this change?

Does the |rps_| become unused? If so, you can delete
reference_picture_selection* too. (If not, I'll delete it later).

[pbos-webrtc, 2017/03/17 17:48:56]

Not sure, I can make sure to take a second pass after this CL, or you, whoever
gets to it first. :)

       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;
+        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) {
@@ skipping 96 matching lines @@
 
   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;
     encoded_images_[encoder_idx]._frameType = kVideoFrameDelta;
     RTPFragmentationHeader frag_info;
-    // token_partitions_ is number of bits used.
-    frag_info.VerifyAndAllocateFragmentationHeader((1 << token_partitions_) +
-                                                   1);
+    // kTokenPartitions is number of bits used.
+    frag_info.VerifyAndAllocateFragmentationHeader((1 << kTokenPartitions) + 1);
     CodecSpecificInfo codec_specific;
     const vpx_codec_cx_pkt_t* pkt = NULL;
     while ((pkt = vpx_codec_get_cx_data(&encoders_[encoder_idx], &iter)) !=
            NULL) {
       switch (pkt->kind) {
         case VPX_CODEC_CX_FRAME_PKT: {
           size_t length = encoded_images_[encoder_idx]._length;
           if (pkt->data.frame.sz + length >
               encoded_images_[encoder_idx]._size) {
             uint8_t* buffer = new uint8_t[pkt->data.frame.sz + length];
@@ skipping 76 matching lines @@
   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*/),
+    : use_postproc_arm_(webrtc::field_trial::FindFullName(
+                            kVp8PostProcArmFieldTrial) == "Enabled"),
+      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") {}
+      key_frame_required_(true) {}
 
 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;
-  }
+  vpx_codec_flags_t flags = use_postproc_arm_ ? VPX_CODEC_USE_POSTPROC : 0;
 #else
-  flags = VPX_CODEC_USE_POSTPROC;
+  vpx_codec_flags_t flags = VPX_CODEC_USE_POSTPROC;
 #endif
 
   if (vpx_codec_dec_init(decoder_, vpx_codec_vp8_dx(), &cfg, flags)) {
     delete decoder_;
     decoder_ = nullptr;
     return WEBRTC_VIDEO_CODEC_MEMORY;
   }
 
-  // Save VideoCodec instance for later; mainly for duplicating the decoder.
-  if (&codec_ != inst)
-    codec_ = *inst;
   propagation_cnt_ = -1;
-
   inited_ = true;
 
   // Always start with a complete key frame.
   key_frame_required_ = true;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int VP8DecoderImpl::Decode(const EncodedImage& input_image,
                            bool missing_frames,
                            const RTPFragmentationHeader* fragmentation,
@@ skipping 43 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).
-  // Reset on a key frame refresh.
-  if (!feedback_mode_) {
-    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_++;
-    }
+  // Restrict error propagation using key frame requests.
+  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_++;
   }
 
   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 22 matching lines @@
                    buffer->MutableDataY(), buffer->StrideY(),
                    buffer->MutableDataU(), buffer->StrideU(),
                    buffer->MutableDataV(), buffer->StrideV(),
                    img->d_w, img->d_h);
 
   VideoFrame decoded_image(buffer, timestamp, 0, kVideoRotation_0);
   decoded_image.set_ntp_time_ms(ntp_time_ms);
   decode_complete_callback_->Decoded(decoded_image, rtc::Optional<int32_t>(),
                                      rtc::Optional<uint8_t>(qp));
 
-  // Remember image format for later
-  image_format_ = img->fmt;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int VP8DecoderImpl::RegisterDecodeCompleteCallback(
     DecodedImageCallback* callback) {
   decode_complete_callback_ = callback;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int VP8DecoderImpl::Release() {
   if (decoder_ != NULL) {
     if (vpx_codec_destroy(decoder_)) {
       return WEBRTC_VIDEO_CODEC_MEMORY;
     }
     delete decoder_;
     decoder_ = NULL;
   }
-  if (ref_frame_ != NULL) {
-    vpx_img_free(&ref_frame_->img);
-    delete ref_frame_;
-    ref_frame_ = NULL;
-  }
   buffer_pool_.Release();
   inited_ = false;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 const char* VP8DecoderImpl::ImplementationName() const {
   return "libvpx";
 }
 
-int VP8DecoderImpl::CopyReference(VP8DecoderImpl* copy) {
-  // The type of frame to copy should be set in ref_frame_->frame_type
-  // before the call to this function.
-  if (vpx_codec_control(decoder_, VP8_COPY_REFERENCE, ref_frame_) !=
-      VPX_CODEC_OK) {
-    return -1;
-  }
-  if (vpx_codec_control(copy->decoder_, VP8_SET_REFERENCE, ref_frame_) !=
-      VPX_CODEC_OK) {
-    return -1;
-  }
-  return 0;
-}
-
 }  // namespace webrtc