Move VideoDecoderSoftwareFallbackWrapper from webrtc/video_decoder.h to webrtc/media/engine/

webrtc/video/video_decoder.cc

Index: webrtc/video/video_decoder.cc
diff --git a/webrtc/video/video_decoder.cc b/webrtc/video/video_decoder.cc
index b15a83f7b3f3038923985c6b1a281278172ed4db..4ac4ff5b0746eab0a54f287421b5532dd187e10a 100644
--- a/webrtc/video/video_decoder.cc
+++ b/webrtc/video/video_decoder.cc
@@ -43,112 +43,6 @@ VideoDecoder* VideoDecoder::Create(VideoDecoder::DecoderType codec_type) {
   return nullptr;
 }
 
-VideoDecoder::DecoderType CodecTypeToDecoderType(VideoCodecType codec_type) {
-  switch (codec_type) {
-    case kVideoCodecH264:
-      return VideoDecoder::kH264;
-    case kVideoCodecVP8:
-      return VideoDecoder::kVp8;
-    case kVideoCodecVP9:
-      return VideoDecoder::kVp9;
-    default:
-      return VideoDecoder::kUnsupportedCodec;
-  }
-}
-
-VideoDecoderSoftwareFallbackWrapper::VideoDecoderSoftwareFallbackWrapper(
-    VideoCodecType codec_type,
-    VideoDecoder* decoder)
-    : decoder_type_(CodecTypeToDecoderType(codec_type)),
-      decoder_(decoder),
-      callback_(nullptr) {
-}
-
-int32_t VideoDecoderSoftwareFallbackWrapper::InitDecode(
-    const VideoCodec* codec_settings,
-    int32_t number_of_cores) {
-  codec_settings_ = *codec_settings;
-  number_of_cores_ = number_of_cores;
-  return decoder_->InitDecode(codec_settings, number_of_cores);
-}
-
-bool VideoDecoderSoftwareFallbackWrapper::InitFallbackDecoder() {
-  RTC_CHECK(decoder_type_ != kUnsupportedCodec)
-      << "Decoder requesting fallback to codec not supported in software.";
-  LOG(LS_WARNING) << "Decoder falling back to software decoding.";
-  fallback_decoder_.reset(VideoDecoder::Create(decoder_type_));
-  if (fallback_decoder_->InitDecode(&codec_settings_, number_of_cores_) !=
-      WEBRTC_VIDEO_CODEC_OK) {
-    LOG(LS_ERROR) << "Failed to initialize software-decoder fallback.";
-    fallback_decoder_.reset();
-    return false;
-  }
-  if (callback_)
-    fallback_decoder_->RegisterDecodeCompleteCallback(callback_);
-  fallback_implementation_name_ =
-      std::string(fallback_decoder_->ImplementationName()) +
-      " (fallback from: " + decoder_->ImplementationName() + ")";
-  return true;
-}
-
-int32_t VideoDecoderSoftwareFallbackWrapper::Decode(
-    const EncodedImage& input_image,
-    bool missing_frames,
-    const RTPFragmentationHeader* fragmentation,
-    const CodecSpecificInfo* codec_specific_info,
-    int64_t render_time_ms) {
-  // Try decoding with the provided decoder on every keyframe or when there's no
-  // fallback decoder. This is the normal case.
-  if (!fallback_decoder_ || input_image._frameType == kVideoFrameKey) {
-    int32_t ret = decoder_->Decode(input_image, missing_frames, fragmentation,
-                                   codec_specific_info, render_time_ms);
-    if (ret == WEBRTC_VIDEO_CODEC_OK) {
-      if (fallback_decoder_) {
-        // Decode OK -> stop using fallback decoder.
-        fallback_decoder_->Release();
-        fallback_decoder_.reset();
-        return WEBRTC_VIDEO_CODEC_OK;
-      }
-    }
-    if (ret != WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE)
-      return ret;
-    if (!fallback_decoder_) {
-      // Try to initialize fallback decoder.
-      if (!InitFallbackDecoder())
-        return ret;
-    }
-  }
-  return fallback_decoder_->Decode(input_image, missing_frames, fragmentation,
-                                   codec_specific_info, render_time_ms);
-}
-
-int32_t VideoDecoderSoftwareFallbackWrapper::RegisterDecodeCompleteCallback(
-    DecodedImageCallback* callback) {
-  callback_ = callback;
-  int32_t ret = decoder_->RegisterDecodeCompleteCallback(callback);
-  if (fallback_decoder_)
-    return fallback_decoder_->RegisterDecodeCompleteCallback(callback);
-  return ret;
-}
-
-int32_t VideoDecoderSoftwareFallbackWrapper::Release() {
-  if (fallback_decoder_)
-    fallback_decoder_->Release();
-  return decoder_->Release();
-}
-
-bool VideoDecoderSoftwareFallbackWrapper::PrefersLateDecoding() const {
-  if (fallback_decoder_)
-    return fallback_decoder_->PrefersLateDecoding();
-  return decoder_->PrefersLateDecoding();
-}
-
-const char* VideoDecoderSoftwareFallbackWrapper::ImplementationName() const {
-  if (fallback_decoder_)
-    return fallback_implementation_name_.c_str();
-  return decoder_->ImplementationName();
-}
-
 NullVideoDecoder::NullVideoDecoder() {}
 
 int32_t NullVideoDecoder::InitDecode(const VideoCodec* codec_settings,