Unify FrameType and VideoFrameType.

webrtc/modules/video_coding/main/source/generic_encoder.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 122 matching lines @@
       LOG(LS_ERROR) << "Failed to initialize the encoder associated with "
                        "payload name: " << settings->plName;
       return -1;
     }
     return 0;
 }
 
 int32_t VCMGenericEncoder::Encode(const VideoFrame& inputFrame,
                                   const CodecSpecificInfo* codecSpecificInfo,
                                   const std::vector<FrameType>& frameTypes) {
-  std::vector<VideoFrameType> video_frame_types(frameTypes.size(),
-                                                kDeltaFrame);
-  VCMEncodedFrame::ConvertFrameTypes(frameTypes, &video_frame_types);
+  for (FrameType frame_type : frameTypes)
+    RTC_DCHECK(frame_type == kVideoFrameKey || frame_type == kVideoFrameDelta);
 
   rotation_ = inputFrame.rotation();
 
   if (vcm_encoded_frame_callback_) {
     // Keep track of the current frame rotation and apply to the output of the
     // encoder. There might not be exact as the encoder could have one frame
     // delay but it should be close enough.
     vcm_encoded_frame_callback_->SetRotation(rotation_);
   }
 
-  int32_t result =
-      encoder_->Encode(inputFrame, codecSpecificInfo, &video_frame_types);
+  int32_t result = encoder_->Encode(inputFrame, codecSpecificInfo, &frameTypes);
   if (is_screenshare_ &&
       result == WEBRTC_VIDEO_CODEC_TARGET_BITRATE_OVERSHOOT) {
     // Target bitrate exceeded, encoder state has been reset - try again.
-    return encoder_->Encode(inputFrame, codecSpecificInfo, &video_frame_types);
+    return encoder_->Encode(inputFrame, codecSpecificInfo, &frameTypes);
   }
 
   return result;
 }
 
 int32_t
 VCMGenericEncoder::SetChannelParameters(int32_t packetLoss, int64_t rtt)
 {
     return encoder_->SetChannelParameters(packetLoss, rtt);
 }
@@ skipping 44 matching lines @@
 
 int32_t
 VCMGenericEncoder::SetPeriodicKeyFrames(bool enable)
 {
     return encoder_->SetPeriodicKeyFrames(enable);
 }
 
 int32_t VCMGenericEncoder::RequestFrame(
     const std::vector<FrameType>& frame_types) {
   VideoFrame image;
-  std::vector<VideoFrameType> video_frame_types(frame_types.size(),
-                                                kDeltaFrame);
-  VCMEncodedFrame::ConvertFrameTypes(frame_types, &video_frame_types);
-  return encoder_->Encode(image, NULL, &video_frame_types);
+  return encoder_->Encode(image, NULL, &frame_types);
 }
 
 int32_t
 VCMGenericEncoder::RegisterEncodeCallback(VCMEncodedFrameCallback* VCMencodedFrameCallback)
 {
     VCMencodedFrameCallback->SetInternalSource(internal_source_);
     vcm_encoded_frame_callback_ = VCMencodedFrameCallback;
     return encoder_->RegisterEncodeCompleteCallback(VCMencodedFrameCallback);
 }
 
@@ skipping 47 matching lines @@
 VCMEncodedFrameCallback::SetTransportCallback(VCMPacketizationCallback* transport)
 {
     _sendCallback = transport;
     return VCM_OK;
 }
 
 int32_t VCMEncodedFrameCallback::Encoded(
     const EncodedImage& encodedImage,
     const CodecSpecificInfo* codecSpecificInfo,
     const RTPFragmentationHeader* fragmentationHeader) {
+  RTC_DCHECK(encodedImage._frameType == kVideoFrameKey ||
+             encodedImage._frameType == kVideoFrameDelta);
   post_encode_callback_->Encoded(encodedImage, NULL, NULL);
 
   if (_sendCallback == NULL) {
     return VCM_UNINITIALIZED;
   }
 
 #ifdef DEBUG_ENCODER_BIT_STREAM
   if (_bitStreamAfterEncoder != NULL) {
     fwrite(encodedImage._buffer, 1, encodedImage._length,
            _bitStreamAfterEncoder);
@@ skipping 23 matching lines @@
 }
 
 void
 VCMEncodedFrameCallback::SetMediaOpt(
     media_optimization::MediaOptimization *mediaOpt)
 {
     _mediaOpt = mediaOpt;
 }
 
 }  // namespace webrtc