Make MediaCodecEncoder fallback to a software encoder on failure.

webrtc/video/video_encoder.cc

 /*
  *  Copyright (c) 2015 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.
  */
 
 #include "webrtc/video_encoder.h"
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/video_coding/codecs/h264/include/h264.h"
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
 #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h"
 
 namespace webrtc {
 VideoEncoder* VideoEncoder::Create(VideoEncoder::EncoderType codec_type) {
+  RTC_DCHECK(IsSupportedSoftware(codec_type));
   switch (codec_type) {
     case kH264:
-      RTC_DCHECK(H264Encoder::IsSupported());
       return H264Encoder::Create();
     case kVp8:
       return VP8Encoder::Create();
     case kVp9:
-      RTC_DCHECK(VP9Encoder::IsSupported());
       return VP9Encoder::Create();
     case kUnsupportedCodec:
       RTC_NOTREACHED();
       return nullptr;
   }
   RTC_NOTREACHED();
   return nullptr;
 }
 
-VideoEncoder::EncoderType CodecToEncoderType(VideoCodecType codec_type) {
+bool VideoEncoder::IsSupportedSoftware(EncoderType codec_type) {
+  switch (codec_type) {
+    case kH264:
+      return H264Encoder::IsSupported();
+    case kVp8:
+      return true;
+    case kVp9:
+      return VP9Encoder::IsSupported();
+    case kUnsupportedCodec:
+      RTC_NOTREACHED();
+      return false;
+  }
+  RTC_NOTREACHED();
+  return false;
+}
+
+VideoEncoder::EncoderType VideoEncoder::CodecToEncoderType(
+    VideoCodecType codec_type) {
   switch (codec_type) {
     case kVideoCodecH264:
       return VideoEncoder::kH264;
     case kVideoCodecVP8:
       return VideoEncoder::kVp8;
     case kVideoCodecVP9:
       return VideoEncoder::kVp9;
     default:
       return VideoEncoder::kUnsupportedCodec;
   }
 }
 
 VideoEncoderSoftwareFallbackWrapper::VideoEncoderSoftwareFallbackWrapper(
     VideoCodecType codec_type,
     webrtc::VideoEncoder* encoder)
     : rates_set_(false),
       channel_parameters_set_(false),
       encoder_type_(CodecToEncoderType(codec_type)),
       encoder_(encoder),
       callback_(nullptr) {}
 
 bool VideoEncoderSoftwareFallbackWrapper::InitFallbackEncoder() {
-  RTC_CHECK(encoder_type_ != kUnsupportedCodec)
-      << "Encoder requesting fallback to codec not supported in software.";
+  if (!VideoEncoder::IsSupportedSoftware(encoder_type_)) {
+    LOG(LS_WARNING)
+        << "Encoder requesting fallback to codec not supported in software.";
+    return false;
+  }
   fallback_encoder_.reset(VideoEncoder::Create(encoder_type_));
   if (fallback_encoder_->InitEncode(&codec_settings_, number_of_cores_,
                                     max_payload_size_) !=
       WEBRTC_VIDEO_CODEC_OK) {
     LOG(LS_ERROR) << "Failed to initialize software-encoder fallback.";
     fallback_encoder_->Release();
     fallback_encoder_.reset();
     return false;
   }
   // Replay callback, rates, and channel parameters.
@@ skipping 65 matching lines @@
 
 int32_t VideoEncoderSoftwareFallbackWrapper::Encode(
     const VideoFrame& frame,
     const CodecSpecificInfo* codec_specific_info,
     const std::vector<FrameType>* frame_types) {
   if (fallback_encoder_)
     return fallback_encoder_->Encode(frame, codec_specific_info, frame_types);
   int32_t ret = encoder_->Encode(frame, codec_specific_info, frame_types);
   // If requested, try a software fallback.
   if (ret == WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE && InitFallbackEncoder()) {
+    if (frame.video_frame_buffer()->native_handle() &&
+        !fallback_encoder_->SupportsNativeHandle()) {
+      LOG(LS_WARNING) << "Fallback encoder doesn't support native frames, "
+                      << "dropping one frame.";
+      return WEBRTC_VIDEO_CODEC_ERROR;
+    }
+
     // Fallback was successful, so start using it with this frame.
     return fallback_encoder_->Encode(frame, codec_specific_info, frame_types);
   }
   return ret;
 }
 
 int32_t VideoEncoderSoftwareFallbackWrapper::SetChannelParameters(
     uint32_t packet_loss,
     int64_t rtt) {
   channel_parameters_set_ = true;
@@ skipping 22 matching lines @@
   return encoder_->OnDroppedFrame();
 }
 
 bool VideoEncoderSoftwareFallbackWrapper::SupportsNativeHandle() const {
   if (fallback_encoder_)
     return fallback_encoder_->SupportsNativeHandle();
   return encoder_->SupportsNativeHandle();
 }
 
 }  // namespace webrtc