Remove VideoFrameType aliases for FrameType.

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 774 matching lines @@
   for (size_t i = 0; i < key_frame_request_.size() && i < send_stream_.size();
        ++i) {
     if (key_frame_request_[i] && send_stream_[i]) {
       send_key_frame = true;
       break;
     }
   }
   if (!send_key_frame && frame_types) {
     for (size_t i = 0; i < frame_types->size() && i < send_stream_.size();
          ++i) {
-      if ((*frame_types)[i] == kKeyFrame && send_stream_[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) {
@@ skipping 157 matching lines @@
   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;
-    encoded_images_[encoder_idx]._frameType = kDeltaFrame;
+    encoded_images_[encoder_idx]._frameType = kVideoFrameDelta;
     RTPFragmentationHeader frag_info;
     // token_partitions_ is number of bits used.
     frag_info.VerifyAndAllocateFragmentationHeader((1 << token_partitions_)
                                                    + 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: {
@@ skipping 10 matching lines @@
           ++part_idx;
           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 = kKeyFrame;
+          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_ =
@@ skipping 150 matching lines @@
   if (last_frame_width_ * last_frame_height_ <= 640 * 360) {
     ppcfg.post_proc_flag |= VP8_DEMACROBLOCK;
   }
   // Strength of deblocking filter. Valid range:[0,16]
   ppcfg.deblocking_level = 3;
   vpx_codec_control(decoder_, VP8_SET_POSTPROC, &ppcfg);
 #endif
 
   // Always start with a complete key frame.
   if (key_frame_required_) {
-    if (input_image._frameType != kKeyFrame)
+    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 == kKeyFrame && 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_++;
     }
   }
@@ skipping 32 matching lines @@
                        VPX_DL_REALTIME)) {
     // Reset to avoid requesting key frames too often.
     if (propagation_cnt_ > 0) {
       propagation_cnt_ = 0;
     }
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
 #endif
 
   // Store encoded frame if key frame. (Used in Copy method.)
-  if (input_image._frameType == kKeyFrame && input_image._buffer != NULL) {
+  if (input_image._frameType == kVideoFrameKey && input_image._buffer != NULL) {
     const uint32_t bytes_to_copy = input_image._length;
     if (last_keyframe_._size < bytes_to_copy) {
       delete [] last_keyframe_._buffer;
       last_keyframe_._buffer = NULL;
       last_keyframe_._size = 0;
     }
     uint8_t* temp_buffer = last_keyframe_._buffer;  // Save buffer ptr.
     uint32_t temp_size = last_keyframe_._size;  // Save size.
     last_keyframe_ = input_image;  // Shallow copy.
     last_keyframe_._buffer = temp_buffer;  // Restore buffer ptr.
@@ skipping 13 matching lines @@
   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 == kKeyFrame && !input_image._completeFrame)
+    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;
@@ skipping 121 matching lines @@
     return -1;
   }
   if (vpx_codec_control(copy->decoder_, VP8_SET_REFERENCE, ref_frame_)
       != VPX_CODEC_OK) {
     return -1;
   }
   return 0;
 }
 
 }  // namespace webrtc