diff --git a/src/modules/video_coding/codecs/i420/main/interface/i420.h b/src/modules/video_coding/codecs/i420/main/interface/i420.h
index fb4ba8c1cf..068c8b3d7a 100644
--- a/src/modules/video_coding/codecs/i420/main/interface/i420.h
+++ b/src/modules/video_coding/codecs/i420/main/interface/i420.h
@@ -50,7 +50,7 @@ public:
     virtual WebRtc_Word32
         Encode(const RawImage& inputImage,
                const CodecSpecificInfo* /*codecSpecificInfo*/,
-               const VideoFrameType* /*frameTypes*/);
+               const VideoFrameType /*frameTypes*/);
 
 // Register an encode complete callback object.
 //
diff --git a/src/modules/video_coding/codecs/i420/main/source/i420.cc b/src/modules/video_coding/codecs/i420/main/source/i420.cc
index b73a00a724..b7f60de4ff 100644
--- a/src/modules/video_coding/codecs/i420/main/source/i420.cc
+++ b/src/modules/video_coding/codecs/i420/main/source/i420.cc
@@ -87,7 +87,7 @@ I420Encoder::InitEncode(const VideoCodec* codecSettings,
 WebRtc_Word32
 I420Encoder::Encode(const RawImage& inputImage,
                     const CodecSpecificInfo* /*codecSpecificInfo*/,
-                    const VideoFrameType* /*frameTypes*/)
+                    const VideoFrameType /*frameType*/)
 {
     if (!_inited)
     {
diff --git a/src/modules/video_coding/codecs/interface/mock/mock_video_codec_interface.h b/src/modules/video_coding/codecs/interface/mock/mock_video_codec_interface.h
index f61fce564a..caa0866431 100644
--- a/src/modules/video_coding/codecs/interface/mock/mock_video_codec_interface.h
+++ b/src/modules/video_coding/codecs/interface/mock/mock_video_codec_interface.h
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *  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
@@ -39,7 +39,7 @@ class MockVideoEncoder : public VideoEncoder {
   MOCK_METHOD3(Encode,
                WebRtc_Word32(const RawImage& inputImage,
                              const CodecSpecificInfo* codecSpecificInfo,
-                             const VideoFrameType* frameType));
+                             const VideoFrameType frameType));
   MOCK_METHOD1(RegisterEncodeCompleteCallback,
                WebRtc_Word32(EncodedImageCallback* callback));
   MOCK_METHOD0(Release, WebRtc_Word32());
diff --git a/src/modules/video_coding/codecs/interface/video_codec_interface.h b/src/modules/video_coding/codecs/interface/video_codec_interface.h
index 9aa5cb77eb..5e69988e22 100644
--- a/src/modules/video_coding/codecs/interface/video_codec_interface.h
+++ b/src/modules/video_coding/codecs/interface/video_codec_interface.h
@@ -97,10 +97,9 @@ public:
     //          - frameType         : The frame type to encode
     //
     // Return value                 : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.
-    virtual WebRtc_Word32
-    Encode(const RawImage& inputImage,
-           const CodecSpecificInfo* codecSpecificInfo,
-           const VideoFrameType* frameTypes) = 0;
+    virtual WebRtc_Word32 Encode(const RawImage& inputImage,
+                                 const CodecSpecificInfo* codecSpecificInfo,
+                                 const VideoFrameType frameType) = 0;
 
     // Register an encode complete callback object.
     //
diff --git a/src/modules/video_coding/codecs/test/videoprocessor.cc b/src/modules/video_coding/codecs/test/videoprocessor.cc
index 8b1351300e..f12ad4de9a 100644
--- a/src/modules/video_coding/codecs/test/videoprocessor.cc
+++ b/src/modules/video_coding/codecs/test/videoprocessor.cc
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *  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
@@ -146,7 +146,7 @@ bool VideoProcessorImpl::ProcessFrame(int frame_number) {
       frame_type = kKeyFrame;
     }
     WebRtc_Word32 encode_result = encoder_->Encode(source_frame_, NULL,
-                                                   &frame_type);
+                                                   frame_type);
     if (encode_result != WEBRTC_VIDEO_CODEC_OK) {
       fprintf(stderr, "Failed to encode frame %d, return code: %d\n",
               frame_number, encode_result);
diff --git a/src/modules/video_coding/codecs/test_framework/normal_async_test.cc b/src/modules/video_coding/codecs/test_framework/normal_async_test.cc
index e37975849b..8570ce79d4 100644
--- a/src/modules/video_coding/codecs/test_framework/normal_async_test.cc
+++ b/src/modules/video_coding/codecs/test_framework/normal_async_test.cc
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *  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
@@ -458,7 +458,7 @@ NormalAsyncTest::Encode()
     }
 
     webrtc::CodecSpecificInfo* codecSpecificInfo = CreateEncoderSpecificInfo();
-    int ret = _encoder->Encode(rawImage, codecSpecificInfo, &frameType);
+    int ret = _encoder->Encode(rawImage, codecSpecificInfo, frameType);
     EXPECT_EQ(ret, WEBRTC_VIDEO_CODEC_OK);
     if (codecSpecificInfo != NULL)
     {
diff --git a/src/modules/video_coding/codecs/test_framework/performance_test.cc b/src/modules/video_coding/codecs/test_framework/performance_test.cc
index 250400ca93..415cd7ba27 100644
--- a/src/modules/video_coding/codecs/test_framework/performance_test.cc
+++ b/src/modules/video_coding/codecs/test_framework/performance_test.cc
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *  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
@@ -273,7 +273,7 @@ bool PerformanceTest::Encode()
         frameType = kKeyFrame;
     }
     webrtc::CodecSpecificInfo* codecSpecificInfo = CreateEncoderSpecificInfo();
-    int ret = _encoder->Encode(rawImage, codecSpecificInfo, &frameType);
+    int ret = _encoder->Encode(rawImage, codecSpecificInfo, frameType);
     EXPECT_EQ(ret, WEBRTC_VIDEO_CODEC_OK);
     if (codecSpecificInfo != NULL)
     {
diff --git a/src/modules/video_coding/codecs/test_framework/unit_test.cc b/src/modules/video_coding/codecs/test_framework/unit_test.cc
index 99bd7fbf8c..623303a7c6 100644
--- a/src/modules/video_coding/codecs/test_framework/unit_test.cc
+++ b/src/modules/video_coding/codecs/test_framework/unit_test.cc
@@ -239,7 +239,7 @@ UnitTest::Setup()
     // Ensures our initial parameters are valid.
     EXPECT_TRUE(_encoder->InitEncode(&_inst, 1, 1440) == WEBRTC_VIDEO_CODEC_OK);
     VideoFrameType videoFrameType = kDeltaFrame;
-    _encoder->Encode(image, NULL, &videoFrameType);
+    _encoder->Encode(image, NULL, videoFrameType);
     _refEncFrameLength = WaitForEncodedFrame();
     ASSERT_TRUE(_refEncFrameLength > 0);
     _refEncFrame = new unsigned char[_refEncFrameLength];
@@ -268,7 +268,7 @@ UnitTest::Setup()
             _inputVideoBuffer.SetWidth(_source->GetWidth());
             _inputVideoBuffer.SetHeight(_source->GetHeight());
             VideoBufferToRawImage(_inputVideoBuffer, image);
-            _encoder->Encode(image, NULL, &videoFrameType);
+            _encoder->Encode(image, NULL, videoFrameType);
             ASSERT_TRUE(WaitForEncodedFrame() > 0);
         }
         EncodedImage encodedImage;
@@ -371,7 +371,7 @@ UnitTest::Perform()
     // We want to revert the initialization done in Setup().
     EXPECT_TRUE(_encoder->Release() == WEBRTC_VIDEO_CODEC_OK);
     VideoBufferToRawImage(_inputVideoBuffer, inputImage);
-    EXPECT_TRUE(_encoder->Encode(inputImage, NULL, &videoFrameType )
+    EXPECT_TRUE(_encoder->Encode(inputImage, NULL, videoFrameType)
                == WEBRTC_VIDEO_CODEC_UNINITIALIZED);
 
     //-- InitEncode() errors --
@@ -437,7 +437,7 @@ UnitTest::Perform()
     // inputVideoBuffer unallocated.
     _inputVideoBuffer.Free();
     VideoBufferToRawImage(_inputVideoBuffer, inputImage);
-    EXPECT_TRUE(_encoder->Encode(inputImage, NULL, &videoFrameType) ==
+    EXPECT_TRUE(_encoder->Encode(inputImage, NULL, videoFrameType) ==
         WEBRTC_VIDEO_CODEC_ERR_PARAMETER);
     _inputVideoBuffer.VerifyAndAllocate(_lengthSourceFrame);
     _inputVideoBuffer.CopyBuffer(_lengthSourceFrame, _refFrame);
@@ -449,7 +449,7 @@ UnitTest::Perform()
     for (int i = 1; i <= 60; i++)
     {
         VideoFrameType frameType = !(i % 2) ? kKeyFrame : kDeltaFrame;
-        EXPECT_TRUE(_encoder->Encode(inputImage, NULL, &frameType) ==
+        EXPECT_TRUE(_encoder->Encode(inputImage, NULL, frameType) ==
             WEBRTC_VIDEO_CODEC_OK);
         EXPECT_TRUE(WaitForEncodedFrame() > 0);
     }
@@ -457,12 +457,12 @@ UnitTest::Perform()
     // Init then encode.
     _encodedVideoBuffer.UpdateLength(0);
     _encodedVideoBuffer.Reset();
-    EXPECT_TRUE(_encoder->Encode(inputImage, NULL, &videoFrameType) ==
+    EXPECT_TRUE(_encoder->Encode(inputImage, NULL, videoFrameType) ==
         WEBRTC_VIDEO_CODEC_OK);
     EXPECT_TRUE(WaitForEncodedFrame() > 0);
 
     EXPECT_TRUE(_encoder->InitEncode(&_inst, 1, 1440) == WEBRTC_VIDEO_CODEC_OK);
-    _encoder->Encode(inputImage, NULL, &videoFrameType);
+    _encoder->Encode(inputImage, NULL, videoFrameType);
     frameLength = WaitForEncodedFrame();
     EXPECT_TRUE(frameLength > 0);
     EXPECT_TRUE(CheckIfBitExact(_refEncFrame, _refEncFrameLength,
@@ -471,11 +471,11 @@ UnitTest::Perform()
     // Reset then encode.
     _encodedVideoBuffer.UpdateLength(0);
     _encodedVideoBuffer.Reset();
-    EXPECT_TRUE(_encoder->Encode(inputImage, NULL, &videoFrameType) ==
+    EXPECT_TRUE(_encoder->Encode(inputImage, NULL, videoFrameType) ==
         WEBRTC_VIDEO_CODEC_OK);
     WaitForEncodedFrame();
     EXPECT_TRUE(_encoder->InitEncode(&_inst, 1, 1440) == WEBRTC_VIDEO_CODEC_OK);
-    _encoder->Encode(inputImage, NULL, &videoFrameType);
+    _encoder->Encode(inputImage, NULL, videoFrameType);
     frameLength = WaitForEncodedFrame();
     EXPECT_TRUE(frameLength > 0);
     EXPECT_TRUE(CheckIfBitExact(_refEncFrame, _refEncFrameLength,
@@ -484,12 +484,12 @@ UnitTest::Perform()
     // Release then encode.
     _encodedVideoBuffer.UpdateLength(0);
     _encodedVideoBuffer.Reset();
-    EXPECT_TRUE(_encoder->Encode(inputImage, NULL, &videoFrameType) ==
+    EXPECT_TRUE(_encoder->Encode(inputImage, NULL, videoFrameType) ==
         WEBRTC_VIDEO_CODEC_OK);
     WaitForEncodedFrame();
     EXPECT_TRUE(_encoder->Release() == WEBRTC_VIDEO_CODEC_OK);
     EXPECT_TRUE(_encoder->InitEncode(&_inst, 1, 1440) == WEBRTC_VIDEO_CODEC_OK);
-    _encoder->Encode(inputImage, NULL, &videoFrameType);
+    _encoder->Encode(inputImage, NULL, videoFrameType);
     frameLength = WaitForEncodedFrame();
     EXPECT_TRUE(frameLength > 0);
     EXPECT_TRUE(CheckIfBitExact(_refEncFrame, _refEncFrameLength,
@@ -612,7 +612,7 @@ UnitTest::Perform()
         RawImage tempInput(inputImage._buffer, inputImage._length/4,
                            inputImage._size/4);
         VideoFrameType videoFrameType = kDeltaFrame;
-        _encoder->Encode(tempInput, NULL, &videoFrameType);
+        _encoder->Encode(tempInput, NULL, videoFrameType);
         frameLength = WaitForEncodedFrame();
         EXPECT_TRUE(frameLength > 0);
 
@@ -630,7 +630,7 @@ UnitTest::Perform()
         EXPECT_TRUE(_encoder->Release() == WEBRTC_VIDEO_CODEC_OK);
         EXPECT_TRUE(_encoder->InitEncode(&_inst, 1, 1440) ==
             WEBRTC_VIDEO_CODEC_OK);
-        _encoder->Encode(inputImage, NULL, &videoFrameType);
+        _encoder->Encode(inputImage, NULL, videoFrameType);
         frameLength = WaitForEncodedFrame();
         EXPECT_TRUE(frameLength > 0);
 
@@ -697,9 +697,7 @@ UnitTest::Perform()
         _inputVideoBuffer.SetTimeStamp(frames);
         VideoBufferToRawImage(_inputVideoBuffer, inputImage);
         VideoFrameType videoFrameType = kDeltaFrame;
-        ASSERT_TRUE(_encoder->Encode(inputImage,
-                                                NULL,
-                                                &videoFrameType) ==
+        ASSERT_TRUE(_encoder->Encode(inputImage, NULL, videoFrameType) ==
             WEBRTC_VIDEO_CODEC_OK);
         frameLength = WaitForEncodedFrame();
         //ASSERT_TRUE(frameLength);
@@ -779,7 +777,7 @@ UnitTest::RateControlTests()
                     static_cast<float>(_inst.maxFramerate)));
             VideoBufferToRawImage(_inputVideoBuffer, inputImage);
             VideoFrameType videoFrameType = kDeltaFrame;
-            ASSERT_EQ(_encoder->Encode(inputImage, NULL, &videoFrameType),
+            ASSERT_EQ(_encoder->Encode(inputImage, NULL, videoFrameType),
                       WEBRTC_VIDEO_CODEC_OK);
             frameLength = WaitForEncodedFrame();
             ASSERT_GE(frameLength, 0u);
diff --git a/src/modules/video_coding/codecs/vp8/main/interface/vp8.h b/src/modules/video_coding/codecs/vp8/main/interface/vp8.h
index ff13386d99..ef38e53f93 100644
--- a/src/modules/video_coding/codecs/vp8/main/interface/vp8.h
+++ b/src/modules/video_coding/codecs/vp8/main/interface/vp8.h
@@ -74,7 +74,7 @@ class VP8Encoder : public VideoEncoder {
 
   virtual int Encode(const RawImage& input_image,
                      const CodecSpecificInfo* codec_specific_info,
-                     const VideoFrameType* frame_types);
+                     const VideoFrameType frame_type);
 
   // Register an encode complete callback object.
   //
diff --git a/src/modules/video_coding/codecs/vp8/main/source/vp8.cc b/src/modules/video_coding/codecs/vp8/main/source/vp8.cc
index 9b0baea2fc..3de5a46184 100644
--- a/src/modules/video_coding/codecs/vp8/main/source/vp8.cc
+++ b/src/modules/video_coding/codecs/vp8/main/source/vp8.cc
@@ -316,7 +316,7 @@ uint32_t VP8Encoder::MaxIntraTarget(uint32_t optimalBuffersize) {
 
 int VP8Encoder::Encode(const RawImage& input_image,
                        const CodecSpecificInfo* codec_specific_info,
-                       const VideoFrameType* frame_types) {
+                       const VideoFrameType frame_type) {
   if (!inited_) {
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
@@ -347,7 +347,7 @@ int VP8Encoder::Encode(const RawImage& input_image,
     flags |= temporal_layers_->EncodeFlags();
   }
 #endif
-  bool send_keyframe = frame_types && (*frame_types == kKeyFrame);
+  bool send_keyframe = (frame_type == kKeyFrame);
   if (send_keyframe) {
     // Key frame request from caller.
     // Will update both golden and alt-ref.
diff --git a/src/modules/video_coding/codecs/vp8/main/test/rps_test.cc b/src/modules/video_coding/codecs/vp8/main/test/rps_test.cc
index cd1c42e7b1..a31ab5f8ed 100644
--- a/src/modules/video_coding/codecs/vp8/main/test/rps_test.cc
+++ b/src/modules/video_coding/codecs/vp8/main/test/rps_test.cc
@@ -162,7 +162,7 @@ bool VP8RpsTest::EncodeRps(RpsDecodeCompleteCallback* decodeCallback) {
     sli_ = false;
   }
   printf("Encoding: %u\n", _framecnt);
-  int ret = _encoder->Encode(rawImage, codecSpecificInfo, &frameType);
+  int ret = _encoder->Encode(rawImage, codecSpecificInfo, frameType);
   if (ret < 0)
     printf("Failed to encode: %u\n", _framecnt);
 
diff --git a/src/modules/video_coding/main/interface/video_coding.h b/src/modules/video_coding/main/interface/video_coding.h
index 54e674207d..1aa047b6b1 100644
--- a/src/modules/video_coding/main/interface/video_coding.h
+++ b/src/modules/video_coding/main/interface/video_coding.h
@@ -256,16 +256,11 @@ public:
         const VideoContentMetrics* contentMetrics = NULL,
         const CodecSpecificInfo* codecSpecificInfo = NULL) = 0;
 
-    // Next frame encoded should be of the type frameType.
-    //
-    // Input:
-    //      - frameType    : The frame type to encode next time a VideoFrame
-    //                       is added to the module.
+    // Next frame encoded should be an intra frame (keyframe).
     //
     // Return value      : VCM_OK, on success.
     //                     < 0,         on error.
-    virtual WebRtc_Word32 FrameTypeRequest(FrameType frameType,
-                                           WebRtc_UWord8 simulcastIdx) = 0;
+    virtual WebRtc_Word32 IntraFrameRequest() = 0;
 
     // Frame Dropper enable. Can be used to disable the frame dropping when the encoder
     // over-uses its bit rate. This API is designed to be used when the encoded frames
diff --git a/src/modules/video_coding/main/source/generic_encoder.cc b/src/modules/video_coding/main/source/generic_encoder.cc
index 87c6c965f0..613c3ecb20 100644
--- a/src/modules/video_coding/main/source/generic_encoder.cc
+++ b/src/modules/video_coding/main/source/generic_encoder.cc
@@ -59,7 +59,7 @@ VCMGenericEncoder::InitEncode(const VideoCodec* settings,
 WebRtc_Word32
 VCMGenericEncoder::Encode(const VideoFrame& inputFrame,
                           const CodecSpecificInfo* codecSpecificInfo,
-                          FrameType* frameType)
+                          const FrameType frameType)
 {
     RawImage rawImage(inputFrame.Buffer(),
                       inputFrame.Length(),
@@ -68,12 +68,9 @@ VCMGenericEncoder::Encode(const VideoFrame& inputFrame,
     rawImage._height    = inputFrame.Height();
     rawImage._timeStamp = inputFrame.TimeStamp();
 
-    VideoFrameType videoFrameTypes[kMaxSimulcastStreams];
-    for (int i = 0; i < kMaxSimulcastStreams; i++)
-    {
-        videoFrameTypes[i] = VCMEncodedFrame::ConvertFrameType(frameType[i]);
-    }
-    return _encoder.Encode(rawImage, codecSpecificInfo, videoFrameTypes);
+    VideoFrameType videoFrameType =
+        VCMEncodedFrame::ConvertFrameType(frameType);
+    return _encoder.Encode(rawImage, codecSpecificInfo, videoFrameType);
 }
 
 WebRtc_Word32
@@ -122,16 +119,10 @@ VCMGenericEncoder::SetPeriodicKeyFrames(bool enable)
     return _encoder.SetPeriodicKeyFrames(enable);
 }
 
-WebRtc_Word32
-VCMGenericEncoder::RequestFrame(FrameType* frameTypes)
-{
-    RawImage image;
-    VideoFrameType videoFrameTypes[kMaxSimulcastStreams];
-    for (int i = 0; i < kMaxSimulcastStreams; i++)
-    {
-        videoFrameTypes[i] = VCMEncodedFrame::ConvertFrameType(frameTypes[i]);
-    }
-    return _encoder.Encode(image, NULL,  videoFrameTypes);
+WebRtc_Word32 VCMGenericEncoder::RequestFrame(const FrameType frameType) {
+  RawImage image;
+  VideoFrameType videoFrameType = VCMEncodedFrame::ConvertFrameType(frameType);
+  return _encoder.Encode(image, NULL,  videoFrameType);
 }
 
 WebRtc_Word32
diff --git a/src/modules/video_coding/main/source/generic_encoder.h b/src/modules/video_coding/main/source/generic_encoder.h
index 99c2ce9600..ce80f054db 100644
--- a/src/modules/video_coding/main/source/generic_encoder.h
+++ b/src/modules/video_coding/main/source/generic_encoder.h
@@ -99,7 +99,7 @@ public:
     */
     WebRtc_Word32 Encode(const VideoFrame& inputFrame,
                          const CodecSpecificInfo* codecSpecificInfo,
-                         FrameType* frameType);
+                         const FrameType frameType);
     /**
     *	Set new target bit rate and frame rate
     * Return Value: new bit rate if OK, otherwise <0s
@@ -125,7 +125,7 @@ public:
 
     WebRtc_Word32 SetPeriodicKeyFrames(bool enable);
 
-    WebRtc_Word32 RequestFrame(FrameType* frameTypes);
+    WebRtc_Word32 RequestFrame(const FrameType frameType);
 
     bool InternalSource() const;
 
diff --git a/src/modules/video_coding/main/source/video_coding_impl.cc b/src/modules/video_coding/main/source/video_coding_impl.cc
index 771f702705..902d119293 100644
--- a/src/modules/video_coding/main/source/video_coding_impl.cc
+++ b/src/modules/video_coding/main/source/video_coding_impl.cc
@@ -72,6 +72,7 @@ _scheduleKeyRequest(false),
 _sendCritSect(CriticalSectionWrapper::CreateCriticalSection()),
 _encoder(),
 _encodedFrameCallback(),
+_nextFrameType(kVideoFrameDelta),
 _mediaOpt(id, clock_),
 _sendCodecType(kVideoCodecUnknown),
 _sendStatsCallback(NULL),
@@ -84,10 +85,6 @@ _retransmissionTimer(10, clock_),
 _keyRequestTimer(500, clock_)
 {
     assert(clock_);
-    for (int i = 0; i < kMaxSimulcastStreams; i++)
-    {
-        _nextFrameType[i] = kVideoFrameDelta;
-    }
 #ifdef DEBUG_DECODER_BIT_STREAM
     _bitStreamBeforeDecoder = fopen("decoderBitStream.bit", "wb");
 #endif
@@ -666,7 +663,7 @@ VideoCodingModuleImpl::AddVideoFrame(const VideoFrame& videoFrame,
     {
         return VCM_UNINITIALIZED;
     }
-    if (_nextFrameType[0] == kFrameEmpty)
+    if (_nextFrameType == kFrameEmpty)
     {
         return VCM_OK;
     }
@@ -700,35 +697,22 @@ VideoCodingModuleImpl::AddVideoFrame(const VideoFrame& videoFrame,
                          "Encode error: %d", ret);
             return ret;
         }
-        for (int i = 0; i < kMaxSimulcastStreams; i++)
-        {
-            _nextFrameType[i] = kVideoFrameDelta; // default frame type
-        }
+        _nextFrameType = kVideoFrameDelta; // default frame type
     }
     return VCM_OK;
 }
 
-// Next frame encoded should be of the type frameType
-// Good for only one frame
-WebRtc_Word32
-VideoCodingModuleImpl::FrameTypeRequest(FrameType frameType, 
-                                        WebRtc_UWord8 simulcastIdx)
-{
-    assert(simulcastIdx < kMaxSimulcastStreams);
-
-
-    CriticalSectionScoped cs(_sendCritSect);
-    _nextFrameType[simulcastIdx] = frameType;
-    if (_encoder != NULL && _encoder->InternalSource())
-    {
-        // Try to request the frame if we have an external encoder with
-        // internal source since AddVideoFrame never will be called.
-        if (_encoder->RequestFrame(_nextFrameType) == WEBRTC_VIDEO_CODEC_OK)
-        {
-            _nextFrameType[simulcastIdx] = kVideoFrameDelta;
-        }
+WebRtc_Word32 VideoCodingModuleImpl::IntraFrameRequest() {
+  CriticalSectionScoped cs(_sendCritSect);
+  _nextFrameType = kVideoFrameKey;
+  if (_encoder != NULL && _encoder->InternalSource()) {
+    // Try to request the frame if we have an external encoder with
+    // internal source since AddVideoFrame never will be called.
+    if (_encoder->RequestFrame(_nextFrameType) == WEBRTC_VIDEO_CODEC_OK) {
+      _nextFrameType = kVideoFrameDelta;
     }
-    return VCM_OK;
+  }
+  return VCM_OK;
 }
 
 WebRtc_Word32
diff --git a/src/modules/video_coding/main/source/video_coding_impl.h b/src/modules/video_coding/main/source/video_coding_impl.h
index 490c847902..6278294af2 100644
--- a/src/modules/video_coding/main/source/video_coding_impl.h
+++ b/src/modules/video_coding/main/source/video_coding_impl.h
@@ -147,9 +147,7 @@ public:
         const VideoContentMetrics* _contentMetrics = NULL,
         const CodecSpecificInfo* codecSpecificInfo = NULL);
 
-    // Next frame encoded should be of the type frameType.
-    virtual WebRtc_Word32 FrameTypeRequest(FrameType frameType,
-                                           WebRtc_UWord8 simulcastIdx);
+    virtual WebRtc_Word32 IntraFrameRequest();
 
     //Enable frame dropper
     virtual WebRtc_Word32 EnableFrameDropper(bool enable);
@@ -295,7 +293,7 @@ private:
     CriticalSectionWrapper*             _sendCritSect; // Critical section for send side
     VCMGenericEncoder*                  _encoder;
     VCMEncodedFrameCallback             _encodedFrameCallback;
-    FrameType                           _nextFrameType[kMaxSimulcastStreams];
+    FrameType                           _nextFrameType;
     VCMMediaOptimization                _mediaOpt;
     VideoCodecType                      _sendCodecType;
     VCMSendStatisticsCallback*          _sendStatsCallback;
diff --git a/src/modules/video_coding/main/test/codec_database_test.cc b/src/modules/video_coding/main/test/codec_database_test.cc
index f9ea3e5803..10487bd01b 100644
--- a/src/modules/video_coding/main/test/codec_database_test.cc
+++ b/src/modules/video_coding/main/test/codec_database_test.cc
@@ -238,7 +238,7 @@ CodecDataBaseTest::Perform(CmdArgs& args)
     // Try to decode a delta frame. Should get a warning since we have enabled the "require key frame" setting
     // and because no frame type request callback has been registered.
     TEST(_vcm->Decode() == VCM_MISSING_CALLBACK);
-    TEST(_vcm->FrameTypeRequest(kVideoFrameKey, 0) == VCM_OK);
+    TEST(_vcm->IntraFrameRequest() == VCM_OK);
     _timeStamp += (WebRtc_UWord32)(9e4 / _frameRate);
     sourceFrame.SetTimeStamp(_timeStamp);
     TEST(_vcm->AddVideoFrame(sourceFrame) == VCM_OK);
@@ -250,7 +250,7 @@ CodecDataBaseTest::Perform(CmdArgs& args)
     sendCodec.width = _width;
     sendCodec.height = _height;
     TEST(_vcm->RegisterReceiveCodec(&sendCodec, 1) == VCM_OK);
-    TEST(_vcm->FrameTypeRequest(kVideoFrameKey, 0) == VCM_OK);
+    TEST(_vcm->IntraFrameRequest() == VCM_OK);
     waitEvent->Wait(33);
     _timeStamp += (WebRtc_UWord32)(9e4 / _frameRate);
     sourceFrame.SetTimeStamp(_timeStamp);
@@ -260,7 +260,7 @@ CodecDataBaseTest::Perform(CmdArgs& args)
     waitEvent->Wait(33);
     _timeStamp += (WebRtc_UWord32)(9e4 / _frameRate);
     sourceFrame.SetTimeStamp(_timeStamp);
-    TEST(_vcm->FrameTypeRequest(kVideoFrameKey, 0) == VCM_OK);
+    TEST(_vcm->IntraFrameRequest() == VCM_OK);
     TEST(_vcm->AddVideoFrame(sourceFrame) == VCM_OK);
     TEST(_vcm->Decode() == VCM_OK);
     TEST(_vcm->ResetDecoder() == VCM_OK);
diff --git a/src/video_engine/test/libvietest/include/tb_I420_codec.h b/src/video_engine/test/libvietest/include/tb_I420_codec.h
index f5467f4ce0..49532b1f9e 100644
--- a/src/video_engine/test/libvietest/include/tb_I420_codec.h
+++ b/src/video_engine/test/libvietest/include/tb_I420_codec.h
@@ -36,7 +36,7 @@ public:
     virtual WebRtc_Word32 Encode(
         const webrtc::RawImage& inputImage,
         const webrtc::CodecSpecificInfo* codecSpecificInfo,
-        const webrtc::VideoFrameType* frameType);
+        const webrtc::VideoFrameType frameType);
 
     virtual WebRtc_Word32 RegisterEncodeCompleteCallback(
         webrtc::EncodedImageCallback* callback);
diff --git a/src/video_engine/test/libvietest/testbed/tb_I420_codec.cc b/src/video_engine/test/libvietest/testbed/tb_I420_codec.cc
index afab59aa27..3f50d14270 100644
--- a/src/video_engine/test/libvietest/testbed/tb_I420_codec.cc
+++ b/src/video_engine/test/libvietest/testbed/tb_I420_codec.cc
@@ -118,7 +118,7 @@ WebRtc_Word32 TbI420Encoder::InitEncode(const webrtc::VideoCodec* inst,
 WebRtc_Word32 TbI420Encoder::Encode(
     const webrtc::RawImage& inputImage,
     const webrtc::CodecSpecificInfo* /*codecSpecificInfo*/,
-    const webrtc::VideoFrameType* /*frameType*/)
+    const webrtc::VideoFrameType /*frameType*/)
 {
     _functionCalls.Encode++;
     if (!_inited)
diff --git a/src/video_engine/vie_capturer.cc b/src/video_engine/vie_capturer.cc
index 23793fd25c..a518c359a7 100644
--- a/src/video_engine/vie_capturer.cc
+++ b/src/video_engine/vie_capturer.cc
@@ -745,15 +745,15 @@ WebRtc_Word32 ViECapturer::InitEncode(const VideoCodec* codec_settings,
 
 WebRtc_Word32 ViECapturer::Encode(const RawImage& input_image,
                                   const CodecSpecificInfo* codec_specific_info,
-                                  const VideoFrameType* frame_types) {
+                                  const VideoFrameType frame_type) {
   CriticalSectionScoped cs(encoding_cs_.get());
   if (!capture_encoder_) {
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
-  if (*frame_types == kKeyFrame) {
+  if (frame_type == kKeyFrame) {
     return capture_encoder_->EncodeFrameType(kVideoFrameKey);
   }
-  if (*frame_types == kSkipFrame) {
+  if (frame_type == kSkipFrame) {
     return capture_encoder_->EncodeFrameType(kFrameEmpty);
   }
   return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
diff --git a/src/video_engine/vie_capturer.h b/src/video_engine/vie_capturer.h
index 9101f288d7..faf507aca6 100644
--- a/src/video_engine/vie_capturer.h
+++ b/src/video_engine/vie_capturer.h
@@ -141,7 +141,7 @@ class ViECapturer
                                    WebRtc_UWord32 max_payload_size);
   virtual WebRtc_Word32 Encode(const RawImage& input_image,
                                const CodecSpecificInfo* codec_specific_info,
-                               const VideoFrameType* frame_types);
+                               const VideoFrameType frame_type);
   virtual WebRtc_Word32 RegisterEncodeCompleteCallback(
       EncodedImageCallback* callback);
   virtual WebRtc_Word32 Release();
diff --git a/src/video_engine/vie_encoder.cc b/src/video_engine/vie_encoder.cc
index 67049cc242..548b208e93 100644
--- a/src/video_engine/vie_encoder.cc
+++ b/src/video_engine/vie_encoder.cc
@@ -84,9 +84,9 @@ ViEEncoder::ViEEncoder(WebRtc_Word32 engine_id, WebRtc_Word32 channel_id,
                ViEId(engine_id, channel_id),
                "%s(engine_id: %d) 0x%p - Constructor", __FUNCTION__, engine_id,
                this);
-  for (int i = 0; i < kMaxSimulcastStreams; i++) {
-    time_last_intra_request_ms_[i] = 0;
-  }
+
+  time_last_intra_request_ms_ = 0;
+
 }
 
 bool ViEEncoder::Init() {
@@ -597,10 +597,10 @@ int ViEEncoder::GetPreferedFrameSettings(int& width,
   return 0;
 }
 
-WebRtc_Word32 ViEEncoder::SendKeyFrame() {
+int ViEEncoder::SendKeyFrame() {
   WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo,
                ViEId(engine_id_, channel_id_), "%s", __FUNCTION__);
-  return vcm_.FrameTypeRequest(kVideoFrameKey, 0);  // Simulcast idx = 0.
+  return vcm_.IntraFrameRequest();
 }
 
 WebRtc_Word32 ViEEncoder::SendCodecStatistics(
@@ -807,25 +807,23 @@ void ViEEncoder::OnRPSIReceived(const WebRtc_Word32 id,
   has_received_rpsi_ = true;
 }
 
-void ViEEncoder::OnReceivedIntraFrameRequest(const WebRtc_Word32 id,
-                                             const FrameType type,
-                                             const WebRtc_UWord8 stream_idx) {
-  assert(stream_idx < kMaxSimulcastStreams);
-
+void ViEEncoder::OnReceivedIntraFrameRequest(const WebRtc_Word32 /*id*/,
+                                             const FrameType /*type*/,
+                                             const WebRtc_UWord8 /*idx*/) {
   // Key frame request from remote side, signal to VCM.
   WEBRTC_TRACE(webrtc::kTraceStateInfo, webrtc::kTraceVideo,
                ViEId(engine_id_, channel_id_), "%s", __FUNCTION__);
 
   WebRtc_Word64 now = TickTime::MillisecondTimestamp();
-  if (time_last_intra_request_ms_[stream_idx] + kViEMinKeyRequestIntervalMs >
+  if (time_last_intra_request_ms_ + kViEMinKeyRequestIntervalMs >
       now) {
     WEBRTC_TRACE(webrtc::kTraceStream, webrtc::kTraceVideo,
                  ViEId(engine_id_, channel_id_),
                  "%s: Not not encoding new intra due to timing", __FUNCTION__);
     return;
   }
-  vcm_.FrameTypeRequest(type, stream_idx);
-  time_last_intra_request_ms_[stream_idx] = now;
+  vcm_.IntraFrameRequest();
+  time_last_intra_request_ms_ = now;
 }
 
 void ViEEncoder::OnNetworkChanged(const WebRtc_Word32 id,
diff --git a/src/video_engine/vie_encoder.h b/src/video_engine/vie_encoder.h
index fa55f8c6bd..311ea5f88e 100644
--- a/src/video_engine/vie_encoder.h
+++ b/src/video_engine/vie_encoder.h
@@ -157,7 +157,7 @@ class ViEEncoder
   VideoCodec send_codec_;
 
   bool paused_;
-  WebRtc_Word64 time_last_intra_request_ms_[kMaxSimulcastStreams];
+  WebRtc_Word64 time_last_intra_request_ms_;
   WebRtc_Word32 channels_dropping_delta_frames_;
   bool drop_next_frame_;