/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et cindent: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef __FFmpegDecoderModule_h__
#define __FFmpegDecoderModule_h__

#include "FFmpegAudioDecoder.h"
#include "FFmpegLibWrapper.h"
#include "FFmpegUtils.h"
#include "FFmpegVideoDecoder.h"
#include "MP4Decoder.h"
#include "PlatformDecoderModule.h"
#include "VideoUtils.h"
#include "VPXDecoder.h"
#include "mozilla/StaticPrefs_media.h"
#include "mozilla/gfx/gfxVars.h"

namespace mozilla {

template <int V>
class FFmpegDecoderModule : public PlatformDecoderModule {
 public:
  static void Init(FFmpegLibWrapper* aLib) {
#if defined(MOZ_USE_HWDECODE)
#  if defined(XP_WIN) && !defined(MOZ_FFVPX_AUDIOONLY)
    if (!XRE_IsGPUProcess()) {
      return;
    }
    static nsTArray<AVCodecID> kCodecIDs({
        AV_CODEC_ID_AV1,
        AV_CODEC_ID_VP9,
    });
    for (const auto& codecId : kCodecIDs) {
      const auto* codec =
          FFmpegDataDecoder<V>::FindHardwareAVCodec(aLib, codecId);
      if (!codec) {
        MOZ_LOG(sPDMLog, LogLevel::Debug,
                ("No codec or decoder for %s on d3d11va",
                 AVCodecToString(codecId)));
        continue;
      }
      for (int i = 0; const AVCodecHWConfig* config =
                          aLib->avcodec_get_hw_config(codec, i);
           ++i) {
        if (config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX) {
          sSupportedHWCodecs.AppendElement(codecId);
          MOZ_LOG(sPDMLog, LogLevel::Debug,
                  ("Support %s on d3d11va", AVCodecToString(codecId)));
          break;
        }
      }
    }
#  elif MOZ_WIDGET_GTK
    // Hardware decoding on Linux should only happen on the RDD process for now.
    if (!XRE_IsRDDProcess()) {
      return;
    }

// UseXXXHWDecode are already set in gfxPlatform at the startup.
#    define ADD_HW_CODEC(codec)                                \
      if (gfx::gfxVars::Use##codec##HwDecode()) {              \
        sSupportedHWCodecs.AppendElement(AV_CODEC_ID_##codec); \
      }

// These proprietary video codecs can only be decoded via hardware by using the
// system ffmpeg, not supported by ffvpx.
#    ifndef FFVPX_VERSION
    ADD_HW_CODEC(H264);
#      if LIBAVCODEC_VERSION_MAJOR >= 55
    ADD_HW_CODEC(HEVC);
#      endif
#    endif  // !FFVPX_VERSION

// The following open video codecs can be decoded via hardware using ffvpx.
#    if LIBAVCODEC_VERSION_MAJOR >= 54
    ADD_HW_CODEC(VP8);
#    endif
#    if LIBAVCODEC_VERSION_MAJOR >= 55
    ADD_HW_CODEC(VP9);
#    endif
#    if LIBAVCODEC_VERSION_MAJOR >= 59
    ADD_HW_CODEC(AV1);
#    endif

    for (const auto& codec : sSupportedHWCodecs) {
      MOZ_LOG(sPDMLog, LogLevel::Debug,
              ("Support %s for hw decoding", AVCodecToString(codec)));
    }
#    undef ADD_HW_CODEC
#  endif  // XP_WIN, MOZ_WIDGET_GTK
#endif    // MOZ_USE_HWDECODE
  }

  static already_AddRefed<PlatformDecoderModule> Create(
      FFmpegLibWrapper* aLib) {
    RefPtr<PlatformDecoderModule> pdm = new FFmpegDecoderModule(aLib);

    return pdm.forget();
  }

  explicit FFmpegDecoderModule(FFmpegLibWrapper* aLib) : mLib(aLib) {}
  virtual ~FFmpegDecoderModule() = default;

  already_AddRefed<MediaDataDecoder> CreateVideoDecoder(
      const CreateDecoderParams& aParams) override {
    if (Supports(SupportDecoderParams(aParams), nullptr).isEmpty()) {
      return nullptr;
    }
    auto decoder = MakeRefPtr<FFmpegVideoDecoder<V>>(
        mLib, aParams.VideoConfig(), aParams.mKnowsCompositor,
        aParams.mImageContainer,
        aParams.mOptions.contains(CreateDecoderParams::Option::LowLatency),
        aParams.mOptions.contains(
            CreateDecoderParams::Option::HardwareDecoderNotAllowed),
        aParams.mTrackingId);

    // Ensure that decoding is exclusively performed using HW decoding in
    // the GPU process. If FFmpeg does not support HW decoding, reset the
    // decoder to allow PDMFactory to select an alternative HW-capable decoder
    // module if available. In contrast, in the RDD process, it is acceptable
    // to fallback to SW decoding when HW decoding is not available.
    if (XRE_IsGPUProcess() &&
        IsHWDecodingSupported(aParams.mConfig.mMimeType) &&
        !decoder->IsHardwareAccelerated()) {
      MOZ_LOG(sPDMLog, LogLevel::Debug,
              ("FFmpeg video decoder can't perform hw decoding, abort!"));
      Unused << decoder->Shutdown();
      decoder = nullptr;
    }
    return decoder.forget();
  }

  already_AddRefed<MediaDataDecoder> CreateAudioDecoder(
      const CreateDecoderParams& aParams) override {
    if (Supports(SupportDecoderParams(aParams), nullptr).isEmpty()) {
      return nullptr;
    }
    RefPtr<MediaDataDecoder> decoder = new FFmpegAudioDecoder<V>(mLib, aParams);
    return decoder.forget();
  }

  media::DecodeSupportSet SupportsMimeType(
      const nsACString& aMimeType,
      DecoderDoctorDiagnostics* aDiagnostics) const override {
    UniquePtr<TrackInfo> trackInfo = CreateTrackInfoWithMIMEType(aMimeType);
    if (!trackInfo) {
      return media::DecodeSupportSet{};
    }
    return Supports(SupportDecoderParams(*trackInfo), aDiagnostics);
  }

  media::DecodeSupportSet Supports(
      const SupportDecoderParams& aParams,
      DecoderDoctorDiagnostics* aDiagnostics) const override {
    // This should only be supported by MFMediaEngineDecoderModule.
    if (aParams.mMediaEngineId) {
      return media::DecodeSupportSet{};
    }

    const auto& trackInfo = aParams.mConfig;
    const nsACString& mimeType = trackInfo.mMimeType;
    if (XRE_IsGPUProcess() && !IsHWDecodingSupported(mimeType)) {
      MOZ_LOG(
          sPDMLog, LogLevel::Debug,
          ("FFmpeg decoder rejects requested type '%s' for hardware decoding",
           mimeType.BeginReading()));
      return media::DecodeSupportSet{};
    }

    // Temporary - forces use of VPXDecoder when alpha is present.
    // Bug 1263836 will handle alpha scenario once implemented. It will shift
    // the check for alpha to PDMFactory but not itself remove the need for a
    // check.
    if (VPXDecoder::IsVPX(mimeType) && trackInfo.GetAsVideoInfo()->HasAlpha()) {
      MOZ_LOG(sPDMLog, LogLevel::Debug,
              ("FFmpeg decoder rejects requested type '%s'",
               mimeType.BeginReading()));
      return media::DecodeSupportSet{};
    }

    if (VPXDecoder::IsVP9(mimeType) &&
        aParams.mOptions.contains(CreateDecoderParams::Option::LowLatency)) {
      // SVC layers are unsupported, and may be used in low latency use cases
      // (WebRTC).
      return media::DecodeSupportSet{};
    }

    if (MP4Decoder::IsHEVC(mimeType) && !StaticPrefs::media_hevc_enabled()) {
      MOZ_LOG(
          sPDMLog, LogLevel::Debug,
          ("FFmpeg decoder rejects requested type '%s' due to being disabled "
           "by the pref",
           mimeType.BeginReading()));
      return media::DecodeSupportSet{};
    }

    AVCodecID videoCodec = FFmpegVideoDecoder<V>::GetCodecId(mimeType);
    AVCodecID audioCodec = FFmpegAudioDecoder<V>::GetCodecId(
        mimeType,
        trackInfo.GetAsAudioInfo() ? *trackInfo.GetAsAudioInfo() : AudioInfo());
    if (audioCodec == AV_CODEC_ID_NONE && videoCodec == AV_CODEC_ID_NONE) {
      MOZ_LOG(sPDMLog, LogLevel::Debug,
              ("FFmpeg decoder rejects requested type '%s'",
               mimeType.BeginReading()));
      return media::DecodeSupportSet{};
    }
    AVCodecID codecId =
        audioCodec != AV_CODEC_ID_NONE ? audioCodec : videoCodec;
    AVCodec* codec = FFmpegDataDecoder<V>::FindAVCodec(mLib, codecId);
    MOZ_LOG(sPDMLog, LogLevel::Debug,
            ("FFmpeg decoder %s requested type '%s'",
             !!codec ? "supports" : "rejects", mimeType.BeginReading()));
    if (!codec) {
      return media::DecodeSupportSet{};
    }
    // This logic is mirrored in FFmpegDataDecoder<LIBAV_VER>::InitDecoder and
    // FFmpegVideoDecoder<LIBAV_VER>::InitVAAPIDecoder. We prefer to use our own
    // OpenH264 decoder through the plugin over ffmpeg by default due to broken
    // decoding with some versions.
    if (!strcmp(codec->name, "libopenh264") &&
        !StaticPrefs::media_ffmpeg_allow_openh264()) {
      MOZ_LOG(sPDMLog, LogLevel::Debug,
              ("FFmpeg decoder rejects as openh264 disabled by pref"));
      return media::DecodeSupportSet{};
    }
    media::DecodeSupportSet support = media::DecodeSupport::SoftwareDecode;
    if (IsHWDecodingSupported(mimeType)) {
      support += media::DecodeSupport::HardwareDecode;
    }
    return support;
  }

 protected:
  bool SupportsColorDepth(
      gfx::ColorDepth aColorDepth,
      DecoderDoctorDiagnostics* aDiagnostics) const override {
#if defined(MOZ_WIDGET_ANDROID)
    return aColorDepth == gfx::ColorDepth::COLOR_8;
#endif
    return true;
  }

  bool IsHWDecodingSupported(const nsACString& aMimeType) const {
    if (!gfx::gfxVars::IsInitialized() ||
        !gfx::gfxVars::CanUseHardwareVideoDecoding()) {
      return false;
    }
#ifdef FFVPX_VERSION
    if (!StaticPrefs::media_ffvpx_hw_enabled()) {
      return false;
    }
#endif
    AVCodecID videoCodec = FFmpegVideoDecoder<V>::GetCodecId(aMimeType);
    return sSupportedHWCodecs.Contains(videoCodec);
  }

 private:
  FFmpegLibWrapper* mLib;
  MOZ_RUNINIT static inline nsTArray<AVCodecID> sSupportedHWCodecs;
};

}  // namespace mozilla

#endif  // __FFmpegDecoderModule_h__