summarylogtreecommitdiffstats
diff options
context:
space:
mode:
authorDenis2023-02-22 22:19:57 +0100
committerDenis2023-02-22 22:19:57 +0100
commit8f879bc7d523ecd541dda763e171fc5c73f9ae50 (patch)
treed79e5429924b07ecd07c0ab8fbceef69258d9d2a
downloadaur-8f879bc7d523ecd541dda763e171fc5c73f9ae50.tar.gz
first release
Diffstat
-rw-r--r--.SRCINFO150
-rw-r--r--.gitignore7
-rw-r--r--010-ffmpeg-add-svt-hevc-gb62f72e.patch674
-rw-r--r--030-ffmpeg-add-svt-vp9-gd9ef3cc.patch786
-rw-r--r--040-ffmpeg-add-av_stream_get_first_dts-for-chromium.patch29
-rw-r--r--060-ffmpeg-fix-segfault-with-avisynthplus.patch11
-rw-r--r--070-ffmpeg-fix-v4l2-memory-leak.patch27
-rw-r--r--080-ffmpeg-vulkan-extensions-names-fixes.patch33
-rw-r--r--LICENSE9
-rw-r--r--PKGBUILD220
10 files changed, 1946 insertions, 0 deletions
diff --git a/.SRCINFO b/.SRCINFO
new file mode 100644
index 000000000000..8ff653074311
--- /dev/null
+++ b/.SRCINFO
@@ -0,0 +1,150 @@
+pkgbase = ffmpeg-nonvidia
+ pkgdesc = Complete solution to record, convert and stream audio and video (all possible features for AMD and no nVidia related stuff)
+ pkgver = 5.1.2
+ pkgrel = 2
+ url = https://www.ffmpeg.org/
+ arch = x86_64
+ license = custom: nonfree and unredistributable
+ makedepends = clang
+ makedepends = amf-headers
+ makedepends = nasm
+ makedepends = opencl-headers
+ makedepends = vulkan-headers
+ makedepends = decklink-sdk
+ depends = alsa-lib
+ depends = aom
+ depends = aribb24
+ depends = avisynthplus
+ depends = bzip2
+ depends = celt
+ depends = codec2
+ depends = dav1d
+ depends = fontconfig
+ depends = freetype2
+ depends = fribidi
+ depends = glslang
+ depends = frei0r-plugins
+ depends = gmp
+ depends = gnutls
+ depends = gsm
+ depends = jack
+ depends = kvazaar
+ depends = ladspa
+ depends = lame
+ depends = libavc1394
+ depends = lcms2
+ depends = lensfun-git
+ depends = libass
+ depends = libbluray
+ depends = libbs2b
+ depends = libcaca
+ depends = libcdio-paranoia
+ depends = libdc1394
+ depends = libdrm
+ depends = libfdk-aac
+ depends = libgme
+ depends = libgl
+ depends = libgcrypt
+ depends = libiec61883
+ depends = libilbc
+ depends = libjxl
+ depends = libmodplug
+ depends = libmysofa
+ depends = libomxil-bellagio
+ depends = libplacebo
+ depends = libpulse
+ depends = librabbitmq-c
+ depends = librsvg
+ depends = libssh
+ depends = libsoxr
+ depends = libtheora
+ depends = libva
+ depends = libvdpau
+ depends = libvorbis
+ depends = libvpx
+ depends = libx11
+ depends = libxcb
+ depends = libxext
+ depends = libxml2
+ depends = libxv
+ depends = libwebp
+ depends = lilv
+ depends = lv2
+ depends = ocl-icd
+ depends = openal
+ depends = opencore-amr
+ depends = openh264
+ depends = openjpeg2
+ depends = libopenmpt
+ depends = opus
+ depends = rav1e
+ depends = rubberband
+ depends = rtmpdump
+ depends = sdl2
+ depends = smbclient
+ depends = snappy
+ depends = sndio
+ depends = speex
+ depends = spirv-tools
+ depends = srt
+ depends = svt-av1
+ depends = svt-hevc
+ depends = svt-vp9
+ depends = tesseract
+ depends = twolame
+ depends = v4l-utils
+ depends = vapoursynth
+ depends = vid.stab
+ depends = vmaf
+ depends = vulkan-icd-loader
+ depends = x264
+ depends = x265
+ depends = xvidcore
+ depends = xz
+ depends = zeromq
+ depends = zimg
+ depends = zlib
+ depends = zvbi
+ depends = chromaprint-fftw
+ depends = davs2
+ depends = flite1
+ depends = libklvanc-git
+ depends = librist
+ depends = pocketsphinx
+ depends = shine
+ depends = uavs3d-git
+ depends = vo-amrwbenc
+ depends = xavs
+ depends = xavs2
+ provides = libavcodec.so
+ provides = libavdevice.so
+ provides = libavfilter.so
+ provides = libavformat.so
+ provides = libavutil.so
+ provides = libpostproc.so
+ provides = libswscale.so
+ provides = libswresample.so
+ provides = ffmpeg
+ provides = ffmpeg-full
+ conflicts = ffmpeg
+ source = https://ffmpeg.org/releases/ffmpeg-5.1.2.tar.xz
+ source = https://ffmpeg.org/releases/ffmpeg-5.1.2.tar.xz.asc
+ source = 010-ffmpeg-add-svt-hevc-gb62f72e.patch::https://raw.githubusercontent.com/OpenVisualCloud/SVT-HEVC/b62f72e752243cee4104cfb41dc7ee409d3ac3e9/ffmpeg_plugin/master-0001-lavc-svt_hevc-add-libsvt-hevc-encoder-wrapper.patch
+ source = 030-ffmpeg-add-svt-vp9-gd9ef3cc.patch::https://raw.githubusercontent.com/OpenVisualCloud/SVT-VP9/d9ef3cc13159143b9afc776c04f67cdfa6284046/ffmpeg_plugin/master-0001-Add-ability-for-ffmpeg-to-run-svt-vp9.patch
+ source = 040-ffmpeg-add-av_stream_get_first_dts-for-chromium.patch
+ source = 060-ffmpeg-fix-segfault-with-avisynthplus.patch
+ source = 070-ffmpeg-fix-v4l2-memory-leak.patch::https://git.ffmpeg.org/gitweb/ffmpeg.git/patch/30aa0c3f4873a92c5e3da8ba8cf030de56bf4cf7
+ source = 080-ffmpeg-vulkan-extensions-names-fixes.patch
+ source = LICENSE
+ validpgpkeys = FCF986EA15E6E293A5644F10B4322F04D67658D8
+ sha256sums = 619e706d662c8420859832ddc259cd4d4096a48a2ce1eefd052db9e440eef3dc
+ sha256sums = SKIP
+ sha256sums = 4da3826aa370572273ef9fb4c0bf2c93a840595b07a671a0412ad0dc9ed8d689
+ sha256sums = e310eedb3dc88c8ad6ffcd6cb6bde1f593ded330ea99b0356724c9d22bcfde4c
+ sha256sums = 2df82046908015bf26bc1303275cf52ba01fa380029a54ea6415373e389e423c
+ sha256sums = b1d68f626168f2409a4b0987acf5b208e7ced2ddab49b11990a10f458d377e9a
+ sha256sums = 9e4e290378028cd4474c36d3e3a25f77d4f40424dbd3115632e20c5734b50979
+ sha256sums = e570c823f4a91699e0fd8eea9e07353e76a5e4156f7af8c2b3d5f65aa7f41d5f
+ sha256sums = 04a7176400907fd7db0d69116b99de49e582a6e176b3bfb36a03e50a4cb26a36
+
+pkgname = ffmpeg-nonvidia
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 000000000000..a024dd37fba1
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,7 @@
+*.tar*
+/pkg
+/src
+/ffmpeg
+*.patch
+*.asc
+!010-ffmpeg-fix-vmaf-model-path.patch \ No newline at end of file
diff --git a/010-ffmpeg-add-svt-hevc-gb62f72e.patch b/010-ffmpeg-add-svt-hevc-gb62f72e.patch
new file mode 100644
index 000000000000..e45655bb603f
--- /dev/null
+++ b/010-ffmpeg-add-svt-hevc-gb62f72e.patch
@@ -0,0 +1,674 @@
+From 8f34ed57e9e80007faea1eb72c0d11307e611b8c Mon Sep 17 00:00:00 2001
+From: Jing Sun <jing.a.sun@intel.com>
+Date: Wed, 21 Nov 2018 11:33:04 +0800
+Subject: [PATCH] lavc/svt_hevc: add libsvt hevc encoder wrapper
+
+Signed-off-by: Zhengxu Huang <zhengxu.huang@intel.com>
+Signed-off-by: Hassene Tmar <hassene.tmar@intel.com>
+Signed-off-by: Jun Zhao <jun.zhao@intel.com>
+Signed-off-by: Jing Sun <jing.a.sun@intel.com>
+Signed-off-by: Austin Hu <austin.hu@intel.com>
+Signed-off-by: Christopher Degawa <ccom@randomderp.com>
+Signed-off-by: Guo Jiansheng <jiansheng.guo@intel.com>
+---
+ configure | 4 +
+ libavcodec/Makefile | 1 +
+ libavcodec/allcodecs.c | 1 +
+ libavcodec/libsvt_hevc.c | 585 +++++++++++++++++++++++++++++++++++++++
+ 4 files changed, 591 insertions(+)
+ create mode 100644 libavcodec/libsvt_hevc.c
+
+diff --git a/configure b/configure
+index 5a167613a4..9897fcaf4d 100755
+--- a/configure
++++ b/configure
+@@ -291,6 +291,7 @@ External library support:
+ --enable-libwebp enable WebP encoding via libwebp [no]
+ --enable-libx264 enable H.264 encoding via x264 [no]
+ --enable-libx265 enable HEVC encoding via x265 [no]
++ --enable-libsvthevc enable HEVC encoding via svt [no]
+ --enable-libxavs enable AVS encoding via xavs [no]
+ --enable-libxavs2 enable AVS2 encoding via xavs2 [no]
+ --enable-libxcb enable X11 grabbing using XCB [autodetect]
+@@ -1864,6 +1865,7 @@ EXTERNAL_LIBRARY_LIST="
+ libsrt
+ libssh
+ libsvtav1
++ libsvthevc
+ libtensorflow
+ libtesseract
+ libtheora
+@@ -3381,6 +3383,7 @@ libx264_encoder_select="atsc_a53"
+ libx264rgb_encoder_deps="libx264"
+ libx264rgb_encoder_select="libx264_encoder"
+ libx265_encoder_deps="libx265"
++libsvt_hevc_encoder_deps="libsvthevc"
+ libxavs_encoder_deps="libxavs"
+ libxavs2_encoder_deps="libxavs2"
+ libxvid_encoder_deps="libxvid"
+@@ -6686,6 +6689,7 @@ enabled mmal && { check_lib mmal interface/mmal/mmal.h mmal_port_co
+ check_lib mmal interface/mmal/mmal.h mmal_port_connect -lmmal_core -lmmal_util -lmmal_vc_client -lbcm_host; } ||
+ die "ERROR: mmal not found" &&
+ check_func_headers interface/mmal/mmal.h "MMAL_PARAMETER_VIDEO_MAX_NUM_CALLBACKS"; }
++enabled libsvthevc && require_pkg_config libsvthevc SvtHevcEnc EbApi.h EbInitHandle
+ enabled openal && { { for al_extralibs in "${OPENAL_LIBS}" "-lopenal" "-lOpenAL32"; do
+ check_lib openal 'AL/al.h' alGetError "${al_extralibs}" && break; done } ||
+ die "ERROR: openal not found"; } &&
+diff --git a/libavcodec/Makefile b/libavcodec/Makefile
+index 3b8f7b5e01..bfd6535345 100644
+--- a/libavcodec/Makefile
++++ b/libavcodec/Makefile
+@@ -1101,6 +1101,7 @@ OBJS-$(CONFIG_LIBWEBP_ANIM_ENCODER) += libwebpenc_common.o libwebpenc_anim
+ OBJS-$(CONFIG_LIBX262_ENCODER) += libx264.o
+ OBJS-$(CONFIG_LIBX264_ENCODER) += libx264.o
+ OBJS-$(CONFIG_LIBX265_ENCODER) += libx265.o
++OBJS-$(CONFIG_LIBSVT_HEVC_ENCODER) += libsvt_hevc.o
+ OBJS-$(CONFIG_LIBXAVS_ENCODER) += libxavs.o
+ OBJS-$(CONFIG_LIBXAVS2_ENCODER) += libxavs2.o
+ OBJS-$(CONFIG_LIBXVID_ENCODER) += libxvid.o
+diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c
+index f0b01051b0..b3f0579a4b 100644
+--- a/libavcodec/allcodecs.c
++++ b/libavcodec/allcodecs.c
+@@ -794,6 +794,7 @@ extern LIBX264_CONST FFCodec ff_libx264_encoder;
+ #endif
+ extern const FFCodec ff_libx264rgb_encoder;
+ extern FFCodec ff_libx265_encoder;
++extern FFCodec ff_libsvt_hevc_encoder;
+ extern const FFCodec ff_libxavs_encoder;
+ extern const FFCodec ff_libxavs2_encoder;
+ extern const FFCodec ff_libxvid_encoder;
+diff --git a/libavcodec/libsvt_hevc.c b/libavcodec/libsvt_hevc.c
+new file mode 100644
+index 0000000000..739144ca0c
+--- /dev/null
++++ b/libavcodec/libsvt_hevc.c
+@@ -0,0 +1,585 @@
++/*
++* Scalable Video Technology for HEVC encoder library plugin
++*
++* Copyright (c) 2019 Intel Corporation
++*
++* This file is part of FFmpeg.
++*
++* FFmpeg is free software; you can redistribute it and/or
++* modify it under the terms of the GNU Lesser General Public
++* License as published by the Free Software Foundation; either
++* version 2.1 of the License, or (at your option) any later version.
++*
++* FFmpeg is distributed in the hope that it will be useful,
++* but WITHOUT ANY WARRANTY; without even the implied warranty of
++* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++* Lesser General Public License for more details.
++*
++* You should have received a copy of the GNU Lesser General Public
++* License along with this program; if not, write to the Free Software
++* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
++*/
++
++#include "EbApi.h"
++
++#include "libavutil/common.h"
++#include "libavutil/frame.h"
++#include "libavutil/opt.h"
++
++#include "codec_internal.h"
++#include "internal.h"
++#include "avcodec.h"
++#include "encode.h"
++
++typedef enum eos_status {
++ EOS_NOT_REACHED = 0,
++ EOS_SENT,
++ EOS_RECEIVED
++}EOS_STATUS;
++
++typedef struct SvtContext {
++ AVClass *class;
++
++ EB_H265_ENC_CONFIGURATION enc_params;
++ EB_COMPONENTTYPE *svt_handle;
++ EB_BUFFERHEADERTYPE in_buf;
++ uint8_t *in_data;
++ EOS_STATUS eos_flag;
++
++ // User options.
++ int profile;
++ int hierarchical_level;
++ int enc_mode;
++ int tier;
++ int level;
++ int rc_mode;
++ int scd;
++ int tune;
++ int base_layer_switch_mode;
++ int qp;
++ int aud;
++ int asm_type;
++ int forced_idr;
++ int la_depth;
++ int thread_count;
++ int target_socket;
++ int high_dynamic_range;
++ int unrestricted_motion_vector;
++ int tile_row_count;
++ int tile_col_count;
++ int tile_slice_mode;
++ int pred_struct;
++ int vid_info;
++} SvtContext;
++
++static int error_mapping(EB_ERRORTYPE svt_ret)
++{
++ switch (svt_ret) {
++ case EB_ErrorInsufficientResources:
++ return AVERROR(ENOMEM);
++
++ case EB_ErrorUndefined:
++ case EB_ErrorInvalidComponent:
++ case EB_ErrorBadParameter:
++ return AVERROR(EINVAL);
++
++ case EB_ErrorDestroyThreadFailed:
++ case EB_ErrorSemaphoreUnresponsive:
++ case EB_ErrorDestroySemaphoreFailed:
++ case EB_ErrorCreateMutexFailed:
++ case EB_ErrorMutexUnresponsive:
++ case EB_ErrorDestroyMutexFailed:
++ return AVERROR_EXTERNAL;
++
++ case EB_NoErrorEmptyQueue:
++ return AVERROR(EAGAIN);
++
++ case EB_ErrorNone:
++ return 0;
++
++ default:
++ return AVERROR_UNKNOWN;
++ }
++}
++
++static void free_buffer(SvtContext *svt_enc)
++{
++ if (svt_enc && svt_enc->in_data) {
++ av_freep(&svt_enc->in_data);
++ svt_enc->in_data = NULL;
++ }
++}
++
++static EB_ERRORTYPE alloc_buffer(SvtContext *svt_enc)
++{
++ EB_BUFFERHEADERTYPE *in_buf = &svt_enc->in_buf;
++ EB_H265_ENC_INPUT *in_data = NULL;
++
++ memset(in_buf, 0, sizeof(*in_buf));
++ in_buf->nSize = sizeof(*in_buf);
++ in_buf->sliceType = EB_INVALID_PICTURE;
++
++ in_data = (EB_H265_ENC_INPUT *)av_mallocz(sizeof(*in_data));
++ if (in_data) {
++ svt_enc->in_data = in_buf->pBuffer = (uint8_t *)in_data;
++ return EB_ErrorNone;
++ } else {
++ return EB_ErrorInsufficientResources;
++ }
++}
++
++static int config_enc_params(EB_H265_ENC_CONFIGURATION *param,
++ AVCodecContext *avctx)
++{
++ SvtContext *svt_enc = avctx->priv_data;
++
++ param->sourceWidth = avctx->width;
++ param->sourceHeight = avctx->height;
++
++ if ((avctx->pix_fmt == AV_PIX_FMT_YUV420P10) ||
++ (avctx->pix_fmt == AV_PIX_FMT_YUV422P10) ||
++ (avctx->pix_fmt == AV_PIX_FMT_YUV444P10)) {
++ av_log(avctx, AV_LOG_DEBUG, "Set 10 bits depth input\n");
++ param->encoderBitDepth = 10;
++ } else {
++ av_log(avctx, AV_LOG_DEBUG, "Set 8 bits depth input\n");
++ param->encoderBitDepth = 8;
++ }
++
++ if ((avctx->pix_fmt == AV_PIX_FMT_YUV420P) ||
++ (avctx->pix_fmt == AV_PIX_FMT_YUV420P10))
++ param->encoderColorFormat = EB_YUV420;
++ else if ((avctx->pix_fmt == AV_PIX_FMT_YUV422P) ||
++ (avctx->pix_fmt == AV_PIX_FMT_YUV422P10))
++ param->encoderColorFormat = EB_YUV422;
++ else
++ param->encoderColorFormat = EB_YUV444;
++
++ param->profile = svt_enc->profile;
++
++ if (FF_PROFILE_HEVC_MAIN_STILL_PICTURE == param->profile) {
++ av_log(avctx, AV_LOG_ERROR, "Main Still Picture Profile not supported\n");
++ return EB_ErrorBadParameter;
++ }
++
++ if ((param->encoderColorFormat >= EB_YUV422) &&
++ (param->profile != FF_PROFILE_HEVC_REXT)) {
++ av_log(avctx, AV_LOG_WARNING, "Rext Profile forced for 422 or 444\n");
++ param->profile = FF_PROFILE_HEVC_REXT;
++ }
++
++ if ((FF_PROFILE_HEVC_MAIN == param->profile) &&
++ (param->encoderBitDepth > 8)) {
++ av_log(avctx, AV_LOG_WARNING, "Main10 Profile forced for 10 bits\n");
++ param->profile = FF_PROFILE_HEVC_MAIN_10;
++ }
++
++ param->targetBitRate = avctx->bit_rate;
++ param->vbvMaxrate = avctx->rc_max_rate;
++ param->vbvBufsize = avctx->rc_buffer_size;
++
++ if (avctx->gop_size > 0)
++ param->intraPeriodLength = avctx->gop_size - 1;
++
++ if ((avctx->framerate.num > 0) && (avctx->framerate.den > 0)) {
++ param->frameRateNumerator = avctx->framerate.num;
++ param->frameRateDenominator =
++ avctx->framerate.den * avctx->ticks_per_frame;
++ } else {
++ param->frameRateNumerator = avctx->time_base.den;
++ param->frameRateDenominator =
++ avctx->time_base.num * avctx->ticks_per_frame;
++ }
++
++ param->hierarchicalLevels = svt_enc->hierarchical_level;
++ param->encMode = svt_enc->enc_mode;
++ param->tier = svt_enc->tier;
++ param->level = svt_enc->level;
++ param->rateControlMode = svt_enc->rc_mode;
++ param->sceneChangeDetection = svt_enc->scd;
++ param->tune = svt_enc->tune;
++ param->baseLayerSwitchMode = svt_enc->base_layer_switch_mode;
++ param->qp = svt_enc->qp;
++ param->accessUnitDelimiter = svt_enc->aud;
++ param->asmType = svt_enc->asm_type;
++ param->intraRefreshType = svt_enc->forced_idr;
++ param->highDynamicRangeInput = svt_enc->high_dynamic_range;
++ param->targetSocket = svt_enc->target_socket;
++ if (param->rateControlMode) {
++ param->maxQpAllowed = avctx->qmax;
++ param->minQpAllowed = avctx->qmin;
++ }
++
++ if (svt_enc->la_depth != -1)
++ param->lookAheadDistance = svt_enc->la_depth;
++
++ if ((svt_enc->thread_count > 0) &&
++ (svt_enc->thread_count < (EB_THREAD_COUNT_MIN_CORE * EB_THREAD_COUNT_FACTOR))) {
++ param->threadCount = EB_THREAD_COUNT_MIN_CORE * EB_THREAD_COUNT_FACTOR;
++ av_log(avctx, AV_LOG_WARNING, "Thread count is set too small, forced to %"PRId32"\n",
++ param->threadCount);
++ } else if (svt_enc->thread_count % EB_THREAD_COUNT_MIN_CORE) {
++ param->threadCount = (svt_enc->thread_count + EB_THREAD_COUNT_MIN_CORE - 1)
++ / EB_THREAD_COUNT_MIN_CORE * EB_THREAD_COUNT_MIN_CORE;
++ av_log(avctx, AV_LOG_DEBUG, "Thread count is rounded to %"PRId32"\n",
++ param->threadCount);
++ } else {
++ param->threadCount = svt_enc->thread_count;
++ }
++
++ if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)
++ param->codeVpsSpsPps = 0;
++ else
++ param->codeVpsSpsPps = 1;
++
++ param->codeEosNal = 1;
++
++ if (svt_enc->unrestricted_motion_vector == 0 || svt_enc->unrestricted_motion_vector == 1) {
++ param->unrestrictedMotionVector = svt_enc->unrestricted_motion_vector;
++ } else {
++ av_log(avctx, AV_LOG_ERROR, "Unrestricted Motion Vector should be set 0 or 1\n");
++ return EB_ErrorBadParameter;
++ }
++
++ if(svt_enc->tile_row_count >= 1 && svt_enc->tile_row_count <= 16) {
++ param->tileRowCount = svt_enc->tile_row_count;
++ } else {
++ av_log(avctx, AV_LOG_ERROR, "Tile Row Count should between 1-16\n");
++ return EB_ErrorBadParameter;
++ }
++
++ if(svt_enc->tile_col_count >= 1 && svt_enc->tile_col_count <= 16) {
++ param->tileColumnCount = svt_enc->tile_col_count;
++ } else {
++ av_log(avctx, AV_LOG_ERROR, "Tile Column Count should between 1-16\n");
++ return EB_ErrorBadParameter;
++ }
++
++ if(svt_enc->tile_slice_mode == 0 || svt_enc->tile_slice_mode == 1) {
++ param->tileSliceMode = svt_enc->tile_slice_mode;
++ } else {
++ av_log(avctx, AV_LOG_ERROR, "Tile Slice Mode should be set 0 or 1\n");
++ return EB_ErrorBadParameter;
++ }
++
++ if(svt_enc->pred_struct >= 0 && svt_enc->pred_struct <= 2) {
++ param->predStructure = svt_enc->pred_struct;
++ } else {
++ av_log(avctx, AV_LOG_ERROR, "Pred Structure should between 0-2\n");
++ return EB_ErrorBadParameter;
++ }
++
++ if(svt_enc->vid_info == 0 || svt_enc->vid_info == 1) {
++ param->videoUsabilityInfo = svt_enc->vid_info;
++ } else {
++ av_log(avctx, AV_LOG_ERROR, "Video Usability Info should be set 0 or 1\n");
++ return EB_ErrorBadParameter;
++ }
++ return EB_ErrorNone;
++}
++
++static void read_in_data(EB_H265_ENC_CONFIGURATION *config,
++ const AVFrame *frame,
++ EB_BUFFERHEADERTYPE *header_ptr)
++{
++ uint8_t is16bit;
++ uint64_t frame_size;
++ EB_H265_ENC_INPUT *in_data = (EB_H265_ENC_INPUT *)header_ptr->pBuffer;
++
++ is16bit = config->encoderBitDepth > 8;
++ frame_size = (uint64_t)(config->sourceWidth * config->sourceHeight) << is16bit;
++
++ in_data->luma = frame->data[0];
++ in_data->cb = frame->data[1];
++ in_data->cr = frame->data[2];
++
++ in_data->yStride = frame->linesize[0] >> is16bit;
++ in_data->cbStride = frame->linesize[1] >> is16bit;
++ in_data->crStride = frame->linesize[2] >> is16bit;
++
++ if (config->encoderColorFormat == EB_YUV420)
++ frame_size *= 3/2u;
++ else if (config->encoderColorFormat == EB_YUV422)
++ frame_size *= 2u;
++ else
++ frame_size *= 3u;
++
++ header_ptr->nFilledLen += frame_size;
++}
++
++static av_cold int eb_enc_init(AVCodecContext *avctx)
++{
++ SvtContext *svt_enc = avctx->priv_data;
++ EB_ERRORTYPE svt_ret;
++
++ svt_enc->eos_flag = EOS_NOT_REACHED;
++
++ svt_ret = EbInitHandle(&svt_enc->svt_handle, svt_enc, &svt_enc->enc_params);
++ if (svt_ret != EB_ErrorNone) {
++ av_log(avctx, AV_LOG_ERROR, "Failed to init handle\n");
++ return error_mapping(svt_ret);
++ }
++
++ svt_ret = config_enc_params(&svt_enc->enc_params, avctx);
++ if (svt_ret != EB_ErrorNone) {
++ av_log(avctx, AV_LOG_ERROR, "Failed to config parameters\n");
++ goto failed_init_handle;
++ }
++
++ svt_ret = EbH265EncSetParameter(svt_enc->svt_handle, &svt_enc->enc_params);
++ if (svt_ret != EB_ErrorNone) {
++ av_log(avctx, AV_LOG_ERROR, "Failed to set parameters\n");
++ goto failed_init_handle;
++ }
++
++ svt_ret = EbInitEncoder(svt_enc->svt_handle);
++ if (svt_ret != EB_ErrorNone) {
++ av_log(avctx, AV_LOG_ERROR, "Failed to init encoder\n");
++ goto failed_init_handle;
++ }
++
++ if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
++ EB_BUFFERHEADERTYPE *header_ptr = NULL;
++
++ svt_ret = EbH265EncStreamHeader(svt_enc->svt_handle, &header_ptr);
++ if (svt_ret != EB_ErrorNone) {
++ av_log(avctx, AV_LOG_ERROR, "Failed to build stream header\n");
++ goto failed_init_encoder;
++ }
++
++ avctx->extradata_size = header_ptr->nFilledLen;
++ avctx->extradata = av_malloc(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
++ if (!avctx->extradata) {
++ av_log(avctx, AV_LOG_ERROR, "Failed to allocate extradata\n");
++ svt_ret = EB_ErrorInsufficientResources;
++ goto failed_init_encoder;
++ }
++ memcpy(avctx->extradata, header_ptr->pBuffer, avctx->extradata_size);
++ memset(avctx->extradata+avctx->extradata_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
++ }
++
++ svt_ret = alloc_buffer(svt_enc);
++ if (svt_ret != EB_ErrorNone) {
++ av_log(avctx, AV_LOG_ERROR, "Failed to alloc data buffer\n");
++ goto failed_init_encoder;
++ }
++ return 0;
++
++failed_init_encoder:
++ EbDeinitEncoder(svt_enc->svt_handle);
++failed_init_handle:
++ EbDeinitHandle(svt_enc->svt_handle);
++ svt_enc->svt_handle = NULL;
++ svt_enc = NULL;
++ return error_mapping(svt_ret);
++}
++
++static int eb_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
++ const AVFrame *frame, int *got_packet)
++{
++ SvtContext *svt_enc = avctx->priv_data;
++ EB_BUFFERHEADERTYPE *header_ptr = &svt_enc->in_buf;
++ EB_ERRORTYPE svt_ret;
++ int av_ret;
++
++ if (EOS_RECEIVED == svt_enc->eos_flag) {
++ *got_packet = 0;
++ return 0;
++ }
++
++ if (!frame) {
++ if (!svt_enc->eos_flag) {
++ svt_enc->eos_flag = EOS_SENT;
++
++ header_ptr->nAllocLen = 0;
++ header_ptr->nFilledLen = 0;
++ header_ptr->nTickCount = 0;
++ header_ptr->nFlags = EB_BUFFERFLAG_EOS;
++ header_ptr->pBuffer = NULL;
++
++ EbH265EncSendPicture(svt_enc->svt_handle, header_ptr);
++
++ av_log(avctx, AV_LOG_DEBUG, "Sent EOS\n");
++ }
++ } else {
++ read_in_data(&svt_enc->enc_params, frame, header_ptr);
++ header_ptr->pts = frame->pts;
++
++ EbH265EncSendPicture(svt_enc->svt_handle, header_ptr);
++
++ av_log(avctx, AV_LOG_DEBUG, "Sent PTS %"PRId64"\n", header_ptr->pts);
++ }
++
++ header_ptr = NULL;
++ svt_ret = EbH265GetPacket(svt_enc->svt_handle, &header_ptr, svt_enc->eos_flag);
++
++ if (svt_ret == EB_NoErrorEmptyQueue) {
++ *got_packet = 0;
++ av_log(avctx, AV_LOG_DEBUG, "Received none\n");
++ return 0;
++ } else if (svt_ret == EB_ErrorMax) {
++ *got_packet = 0;
++ av_log(avctx, AV_LOG_ERROR, "Received NULL packet with error code 0x%X\n", header_ptr->nFlags);
++ return AVERROR_INVALIDDATA;
++ }
++
++ av_log(avctx, AV_LOG_DEBUG, "Received PTS %"PRId64" packet\n", header_ptr->pts);
++
++ av_ret = ff_alloc_packet(avctx, pkt, header_ptr->nFilledLen);
++ if (av_ret) {
++ av_log(avctx, AV_LOG_ERROR, "Failed to allocate a packet\n");
++ EbH265ReleaseOutBuffer(&header_ptr);
++ return av_ret;
++ }
++
++ memcpy(pkt->data, header_ptr->pBuffer, header_ptr->nFilledLen);
++ pkt->size = header_ptr->nFilledLen;
++ pkt->pts = header_ptr->pts;
++ pkt->dts = header_ptr->dts;
++
++ if ((header_ptr->sliceType == EB_IDR_PICTURE) ||
++ (header_ptr->sliceType == EB_I_PICTURE))
++ pkt->flags |= AV_PKT_FLAG_KEY;
++ if (header_ptr->sliceType == EB_NON_REF_PICTURE)
++ pkt->flags |= AV_PKT_FLAG_DISPOSABLE;
++
++ EbH265ReleaseOutBuffer(&header_ptr);
++
++ *got_packet = 1;
++
++ if (EB_BUFFERFLAG_EOS == header_ptr->nFlags)
++ svt_enc->eos_flag = EOS_RECEIVED;
++
++ return 0;
++}
++
++static av_cold int eb_enc_close(AVCodecContext *avctx)
++{
++ SvtContext *svt_enc = avctx->priv_data;
++
++ if (svt_enc) {
++ free_buffer(svt_enc);
++
++ if (svt_enc->svt_handle) {
++ EbDeinitEncoder(svt_enc->svt_handle);
++ EbDeinitHandle(svt_enc->svt_handle);
++ svt_enc->svt_handle = NULL;
++ }
++ }
++
++ return 0;
++}
++
++#define OFFSET(x) offsetof(SvtContext, x)
++#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
++static const AVOption options[] = {
++ { "asm_type", "Assembly instruction set type [0: C Only, 1: Auto]", OFFSET(asm_type),
++ AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE },
++
++ { "aud", "Include Access Unit Delimiter", OFFSET(aud),
++ AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
++
++ { "bl_mode", "Random Access Prediction Structure type setting", OFFSET(base_layer_switch_mode),
++ AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
++
++ { "forced-idr", "If forcing keyframes, force them as IDR frames.", OFFSET(forced_idr),
++ AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, VE },
++
++ { "hielevel", "Hierarchical prediction levels setting", OFFSET(hierarchical_level),
++ AV_OPT_TYPE_INT, { .i64 = 3 }, 0, 3, VE , "hielevel"},
++ { "flat", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "hielevel" },
++ { "1 level", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "hielevel" },
++ { "2 level", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "hielevel" },
++ { "3 level", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 3 }, INT_MIN, INT_MAX, VE, "hielevel" },
++
++ { "la_depth", "Look ahead distance [0, 256]", OFFSET(la_depth),
++ AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 256, VE },
++
++ { "level", "Set level (level_idc)", OFFSET(level),
++ AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 0xff, VE, "level" },
++
++ { "preset", "Encoding preset [0, 12]",
++ OFFSET(enc_mode), AV_OPT_TYPE_INT, { .i64 = 7 }, 0, 12, VE },
++
++ { "profile", "Profile setting, Main Still Picture Profile not supported", OFFSET(profile),
++ AV_OPT_TYPE_INT, { .i64 = FF_PROFILE_HEVC_MAIN }, FF_PROFILE_HEVC_MAIN, FF_PROFILE_HEVC_REXT, VE, "profile"},
++
++ { "qp", "QP value for intra frames", OFFSET(qp),
++ AV_OPT_TYPE_INT, { .i64 = 32 }, 0, 51, VE },
++
++ { "rc", "Bit rate control mode", OFFSET(rc_mode),
++ AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE , "rc"},
++ { "cqp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "rc" },
++ { "vbr", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "rc" },
++
++ { "sc_detection", "Scene change detection", OFFSET(scd),
++ AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE },
++
++ { "socket", "Target CPU socket to use. -1 use all available", OFFSET(target_socket),
++ AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 1, VE },
++
++ { "thread_count", "Number of threads [0: Auto, 96: Min]", OFFSET(thread_count),
++ AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, VE },
++
++ { "tier", "Set tier (general_tier_flag)", OFFSET(tier),
++ AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE, "tier" },
++ { "main", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, 0, 0, VE, "tier" },
++ { "high", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, 0, 0, VE, "tier" },
++
++ { "tune", "Quality tuning mode", OFFSET(tune), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 2, VE, "tune" },
++ { "sq", "Visually optimized mode", 0,
++ AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "tune" },
++ { "oq", "PSNR / SSIM optimized mode", 0,
++ AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "tune" },
++ { "vmaf", "VMAF optimized mode", 0,
++ AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "tune" },
++ { "hdr", "High dynamic range input (HDR10)", OFFSET(high_dynamic_range), AV_OPT_TYPE_INT, { .i64 = 0}, 0, 1, VE, "hdr" },
++ { "umv", "Enables or disables unrestricted motion vectors", OFFSET(unrestricted_motion_vector),
++ AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE },
++ { "tile_row_cnt", "tile count in the row", OFFSET(tile_row_count), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, 16, VE },
++ { "tile_col_cnt", "tile count in the column", OFFSET(tile_col_count), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, 16, VE },
++ { "tile_slice_mode", "per slice per tile, only valid for multi-tile", OFFSET(tile_slice_mode),
++ AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
++ { "pred_struct", "The prediction structure", OFFSET(pred_struct), AV_OPT_TYPE_INT, { .i64 = 2 }, 0, 2, VE },
++ { "vid_info", "Enables or disables sending a vui structure in the HEVC Elementary bitstream.", OFFSET(vid_info),
++ AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
++ {NULL},
++};
++
++static const AVClass class = {
++ .class_name = "libsvt_hevc",
++ .item_name = av_default_item_name,
++ .option = options,
++ .version = LIBAVUTIL_VERSION_INT,
++};
++
++static const FFCodecDefault eb_enc_defaults[] = {
++ { "b", "7M" },
++ { "qmin", "10" },
++ { "qmax", "48" },
++ { "g", "-2" },
++ { NULL },
++};
++
++FFCodec ff_libsvt_hevc_encoder = {
++ .p.name = "libsvt_hevc",
++ .p.long_name = NULL_IF_CONFIG_SMALL("SVT-HEVC(Scalable Video Technology for HEVC) encoder"),
++ .priv_data_size = sizeof(SvtContext),
++ .p.type = AVMEDIA_TYPE_VIDEO,
++ .p.id = AV_CODEC_ID_HEVC,
++ .init = eb_enc_init,
++ FF_CODEC_ENCODE_CB(eb_encode_frame),
++ .close = eb_enc_close,
++ .p.capabilities = AV_CODEC_CAP_DELAY,
++ .p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P,
++ AV_PIX_FMT_YUV420P10,
++ AV_PIX_FMT_YUV422P,
++ AV_PIX_FMT_YUV422P10,
++ AV_PIX_FMT_YUV444P,
++ AV_PIX_FMT_YUV444P10,
++ AV_PIX_FMT_NONE },
++ .p.priv_class = &class,
++ .defaults = eb_enc_defaults,
++ .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
++ .p.wrapper_name = "libsvt_hevc",
++};
+--
+2.17.1
+
diff --git a/030-ffmpeg-add-svt-vp9-gd9ef3cc.patch b/030-ffmpeg-add-svt-vp9-gd9ef3cc.patch
new file mode 100644
index 000000000000..b3e4a320338a
--- /dev/null
+++ b/030-ffmpeg-add-svt-vp9-gd9ef3cc.patch
@@ -0,0 +1,786 @@
+From 9a005fe0e836c0cacef93f2e7a6d7e59bf394cab Mon Sep 17 00:00:00 2001
+From: hassene <hassene.tmar@intel.com>
+Date: Fri, 15 Feb 2019 17:43:54 -0800
+Subject: [PATCH] Add ability for ffmpeg to run svt vp9
+
+Signed-off-by: hassene <hassene.tmar@intel.com>
+Signed-off-by: Jing Sun <jing.a.sun@intel.com>
+Signed-off-by: Austin Hu <austin.hu@intel.com>
+Signed-off-by: Andrei Bich <dronimal@yandex-team.ru>
+Signed-off-by: Guo Jiansheng <jiansheng.guo@intel.com>
+---
+ configure | 4 +
+ libavcodec/Makefile | 1 +
+ libavcodec/allcodecs.c | 1 +
+ libavcodec/libsvt_vp9.c | 699 ++++++++++++++++++++++++++++++++++++++++
+ 4 files changed, 705 insertions(+)
+ create mode 100644 libavcodec/libsvt_vp9.c
+
+diff --git a/configure b/configure
+index 5a167613a4..5d7a347ebf 100755
+--- a/configure
++++ b/configure
+@@ -288,6 +288,7 @@ External library support:
+ --enable-libvorbis enable Vorbis en/decoding via libvorbis,
+ native implementation exists [no]
+ --enable-libvpx enable VP8 and VP9 de/encoding via libvpx [no]
++ --enable-libsvtvp9 enable VP9 encoding via svt [no]
+ --enable-libwebp enable WebP encoding via libwebp [no]
+ --enable-libx264 enable H.264 encoding via x264 [no]
+ --enable-libx265 enable HEVC encoding via x265 [no]
+@@ -1858,6 +1859,7 @@ EXTERNAL_LIBRARY_LIST="
+ libshaderc
+ libshine
+ libsmbclient
++ libsvtvp9
+ libsnappy
+ libsoxr
+ libspeex
+@@ -3373,6 +3375,7 @@ libvpx_vp8_decoder_deps="libvpx"
+ libvpx_vp8_encoder_deps="libvpx"
+ libvpx_vp9_decoder_deps="libvpx"
+ libvpx_vp9_encoder_deps="libvpx"
++libsvt_vp9_encoder_deps="libsvtvp9"
+ libwebp_encoder_deps="libwebp"
+ libwebp_anim_encoder_deps="libwebp"
+ libx262_encoder_deps="libx262"
+@@ -6655,6 +6658,7 @@ enabled libvpx && {
+ fi
+ }
+
++enabled libsvtvp9 && require_pkg_config libsvtvp9 SvtVp9Enc EbSvtVp9Enc.h eb_vp9_svt_init_handle
+ enabled libwebp && {
+ enabled libwebp_encoder && require_pkg_config libwebp "libwebp >= 0.2.0" webp/encode.h WebPGetEncoderVersion
+ enabled libwebp_anim_encoder && check_pkg_config libwebp_anim_encoder "libwebpmux >= 0.4.0" webp/mux.h WebPAnimEncoderOptionsInit; }
+diff --git a/libavcodec/Makefile b/libavcodec/Makefile
+index 3b8f7b5e01..c3926f8745 100644
+--- a/libavcodec/Makefile
++++ b/libavcodec/Makefile
+@@ -1096,6 +1096,7 @@ OBJS-$(CONFIG_LIBVPX_VP8_DECODER) += libvpxdec.o
+ OBJS-$(CONFIG_LIBVPX_VP8_ENCODER) += libvpxenc.o
+ OBJS-$(CONFIG_LIBVPX_VP9_DECODER) += libvpxdec.o libvpx.o
+ OBJS-$(CONFIG_LIBVPX_VP9_ENCODER) += libvpxenc.o libvpx.o
++OBJS-$(CONFIG_LIBSVT_VP9_ENCODER) += libsvt_vp9.o
+ OBJS-$(CONFIG_LIBWEBP_ENCODER) += libwebpenc_common.o libwebpenc.o
+ OBJS-$(CONFIG_LIBWEBP_ANIM_ENCODER) += libwebpenc_common.o libwebpenc_animencoder.o
+ OBJS-$(CONFIG_LIBX262_ENCODER) += libx264.o
+diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c
+index f0b01051b0..36dbad86cd 100644
+--- a/libavcodec/allcodecs.c
++++ b/libavcodec/allcodecs.c
+@@ -779,6 +779,7 @@ extern const FFCodec ff_libvpx_vp8_encoder;
+ extern const FFCodec ff_libvpx_vp8_decoder;
+ extern FFCodec ff_libvpx_vp9_encoder;
+ extern FFCodec ff_libvpx_vp9_decoder;
++extern FFCodec ff_libsvt_vp9_encoder;
+ /* preferred over libwebp */
+ extern const FFCodec ff_libwebp_anim_encoder;
+ extern const FFCodec ff_libwebp_encoder;
+diff --git a/libavcodec/libsvt_vp9.c b/libavcodec/libsvt_vp9.c
+new file mode 100644
+index 0000000000..a7da7023d2
+--- /dev/null
++++ b/libavcodec/libsvt_vp9.c
+@@ -0,0 +1,699 @@
++/*
++* Scalable Video Technology for VP9 encoder library plugin
++*
++* Copyright (c) 2018 Intel Corporation
++*
++* This file is part of FFmpeg.
++*
++* FFmpeg is free software; you can redistribute it and/or
++* modify it under the terms of the GNU Lesser General Public
++* License as published by the Free Software Foundation; either
++* version 2.1 of the License, or (at your option) any later version.
++*
++* FFmpeg is distributed in the hope that it will be useful,
++* but WITHOUT ANY WARRANTY; without even the implied warranty of
++* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
++* Lesser General Public License for more details.
++*
++* You should have received a copy of the GNU Lesser General Public
++* License along with this program; if not, write to the Free Software
++* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
++*/
++
++#include <stdint.h>
++#include "EbSvtVp9ErrorCodes.h"
++#include "EbSvtVp9Enc.h"
++
++#include "libavutil/common.h"
++#include "libavutil/frame.h"
++#include "libavutil/opt.h"
++#include "libavcodec/get_bits.h"
++
++#include "codec_internal.h"
++#include "internal.h"
++#include "encode.h"
++#include "avcodec.h"
++
++#define SUPERFRAME_INDEX_MAX_SIZE 128
++
++#define RECIVED_FRAMES_MAX_SIZE 32
++#define MAX_VP9_SUPERFRAME_SIZE 8
++
++typedef enum eos_status {
++ EOS_NOT_REACHED = 0,
++ EOS_REACHED,
++ EOS_TOTRIGGER
++}EOS_STATUS;
++
++typedef struct SvtReceivedFrameStruct {
++ // fields for AVPacket
++ AVBufferRef *buf;
++ int64_t pts;
++ int64_t dts;
++ int size;
++ int flags;
++
++ // svt fields:
++ int ready_flag; // frame or superframe in data is visible
++ int frames_count;
++ int frames_sizes[MAX_VP9_SUPERFRAME_SIZE];
++} SvtReceivedFrameStruct;
++
++typedef struct SvtContext {
++ AVClass *class;
++
++ EbSvtVp9EncConfiguration enc_params;
++ EbComponentType *svt_handle;
++
++ EbBufferHeaderType *in_buf;
++ int raw_size;
++
++ AVFrame *frame;
++
++ AVBufferPool* pool;
++
++ EOS_STATUS eos_flag;
++
++ // User options.
++ int enc_mode;
++ int rc_mode;
++ int tune;
++ int qp;
++
++ int target_socket;
++
++ int forced_idr;
++
++ int level;
++
++ int base_layer_switch_mode;
++
++
++ int64_t last_ready_dts;
++ SvtReceivedFrameStruct received_frames[RECIVED_FRAMES_MAX_SIZE];
++ int received_frames_size;
++} SvtContext;
++
++static int error_mapping(EbErrorType svt_ret)
++{
++ int err;
++
++ switch (svt_ret) {
++ case EB_ErrorInsufficientResources:
++ err = AVERROR(ENOMEM);
++ break;
++
++ case EB_ErrorUndefined:
++ case EB_ErrorInvalidComponent:
++ case EB_ErrorBadParameter:
++ err = AVERROR(EINVAL);
++ break;
++
++ case EB_ErrorDestroyThreadFailed:
++ case EB_ErrorSemaphoreUnresponsive:
++ case EB_ErrorDestroySemaphoreFailed:
++ case EB_ErrorCreateMutexFailed:
++ case EB_ErrorMutexUnresponsive:
++ case EB_ErrorDestroyMutexFailed:
++ err = AVERROR_EXTERNAL;
++ break;
++
++ case EB_NoErrorEmptyQueue:
++ err = AVERROR(EAGAIN);
++
++ case EB_ErrorNone:
++ err = 0;
++ break;
++
++ default:
++ err = AVERROR_UNKNOWN;
++ }
++
++ return err;
++}
++
++static void free_buffer(SvtContext *svt_enc)
++{
++ if (svt_enc->in_buf) {
++ EbSvtEncInput *in_data = (EbSvtEncInput *)svt_enc->in_buf->p_buffer;
++ av_freep(&in_data);
++ av_freep(&svt_enc->in_buf);
++ }
++ av_buffer_pool_uninit(&svt_enc->pool);
++}
++
++static int alloc_buffer(EbSvtVp9EncConfiguration *config, SvtContext *svt_enc)
++{
++ const size_t luma_size_8bit =
++ config->source_width * config->source_height;
++ const size_t luma_size_10bit =
++ (config->encoder_bit_depth > 8) ? luma_size_8bit : 0;
++
++ EbSvtEncInput *in_data;
++
++ svt_enc->raw_size = ((luma_size_8bit + luma_size_10bit) * 3 / 2) * MAX_VP9_SUPERFRAME_SIZE + SUPERFRAME_INDEX_MAX_SIZE;
++
++ // allocate buffer for in and out
++ svt_enc->in_buf = av_mallocz(sizeof(*svt_enc->in_buf));
++ if (!svt_enc->in_buf)
++ goto failed;
++
++
++ svt_enc->in_buf->p_buffer = (unsigned char *)av_mallocz(sizeof(*in_data));
++ if (!svt_enc->in_buf->p_buffer)
++ goto failed;
++
++ svt_enc->in_buf->size = sizeof(*svt_enc->in_buf);
++ svt_enc->in_buf->p_app_private = NULL;
++
++ svt_enc->pool = av_buffer_pool_init(svt_enc->raw_size, NULL);
++ if (!svt_enc->pool)
++ goto failed;
++
++ svt_enc->received_frames_size = 0;
++ svt_enc->last_ready_dts = -1e9;
++
++ return 0;
++
++failed:
++ free_buffer(svt_enc);
++ return AVERROR(ENOMEM);
++}
++
++static int config_enc_params(EbSvtVp9EncConfiguration *param,
++ AVCodecContext *avctx)
++{
++ SvtContext *svt_enc = avctx->priv_data;
++ int ret;
++ int ten_bits = 0;
++
++ param->source_width = avctx->width;
++ param->source_height = avctx->height;
++
++ if (avctx->pix_fmt == AV_PIX_FMT_YUV420P10LE) {
++ av_log(avctx, AV_LOG_DEBUG , "Encoder 10 bits depth input\n");
++ // Disable Compressed 10-bit format default
++ ten_bits = 1;
++ }
++
++ // Update param from options
++ param->enc_mode = svt_enc->enc_mode;
++ param->level = svt_enc->level;
++ param->rate_control_mode = svt_enc->rc_mode;
++ param->tune = svt_enc->tune;
++ param->base_layer_switch_mode = svt_enc->base_layer_switch_mode;
++ param->qp = svt_enc->qp;
++ param->target_socket = svt_enc->target_socket;
++ param->target_bit_rate = avctx->bit_rate;
++ if (avctx->gop_size > 0)
++ param->intra_period = avctx->gop_size - 1;
++
++ if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
++ param->frame_rate_numerator = avctx->framerate.num;
++ param->frame_rate_denominator = avctx->framerate.den * avctx->ticks_per_frame;
++ } else {
++ param->frame_rate_numerator = avctx->time_base.den;
++ param->frame_rate_denominator = avctx->time_base.num * avctx->ticks_per_frame;
++ }
++
++ if (param->rate_control_mode) {
++ param->max_qp_allowed = avctx->qmax;
++ param->min_qp_allowed = avctx->qmin;
++ }
++
++ if (ten_bits) {
++ param->encoder_bit_depth = 10;
++ }
++
++ ret = alloc_buffer(param, svt_enc);
++
++ return ret;
++}
++
++static void read_in_data(EbSvtVp9EncConfiguration *config,
++ const AVFrame *frame,
++ EbBufferHeaderType *headerPtr)
++{
++ uint8_t is16bit = config->encoder_bit_depth > 8;
++ uint64_t luma_size =
++ (uint64_t)config->source_width * config->source_height<< is16bit;
++ EbSvtEncInput *in_data = (EbSvtEncInput *)headerPtr->p_buffer;
++
++ // support yuv420p and yuv420p010
++ in_data->luma = frame->data[0];
++ in_data->cb = frame->data[1];
++ in_data->cr = frame->data[2];
++
++ // stride info
++ in_data->y_stride = frame->linesize[0] >> is16bit;
++ in_data->cb_stride = frame->linesize[1] >> is16bit;
++ in_data->cr_stride = frame->linesize[2] >> is16bit;
++
++ headerPtr->n_filled_len += luma_size * 3/2u;
++}
++
++static av_cold int eb_enc_init(AVCodecContext *avctx)
++{
++ SvtContext *svt_enc = avctx->priv_data;
++ EbErrorType svt_ret;
++
++ svt_enc->eos_flag = EOS_NOT_REACHED;
++
++ svt_ret = eb_vp9_svt_init_handle(&svt_enc->svt_handle, svt_enc, &svt_enc->enc_params);
++ if (svt_ret != EB_ErrorNone) {
++ av_log(avctx, AV_LOG_ERROR, "Error init encoder handle\n");
++ goto failed;
++ }
++
++ svt_ret = config_enc_params(&svt_enc->enc_params, avctx);
++ if (svt_ret != EB_ErrorNone) {
++ av_log(avctx, AV_LOG_ERROR, "Error configure encoder parameters\n");
++ goto failed_init_handle;
++ }
++
++ svt_ret = eb_vp9_svt_enc_set_parameter(svt_enc->svt_handle, &svt_enc->enc_params);
++ if (svt_ret != EB_ErrorNone) {
++ av_log(avctx, AV_LOG_ERROR, "Error setting encoder parameters\n");
++ goto failed_init_handle;
++ }
++
++ svt_ret = eb_vp9_init_encoder(svt_enc->svt_handle);
++ if (svt_ret != EB_ErrorNone) {
++ av_log(avctx, AV_LOG_ERROR, "Error init encoder\n");
++ goto failed_init_handle;
++ }
++
++ svt_enc->frame = av_frame_alloc();
++ if (!svt_enc->frame)
++ return AVERROR(ENOMEM);
++
++ // if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
++ // EbBufferHeaderType* headerPtr;
++ // headerPtr->size = sizeof(headerPtr);
++ // headerPtr->n_filled_len = 0; /* in/out */
++ // headerPtr->p_buffer = av_malloc(10 * 1024 * 1024);
++ // headerPtr->n_alloc_len = (10 * 1024 * 1024);
++ //
++ // if (!headerPtr->p_buffer) {
++ // av_log(avctx, AV_LOG_ERROR,
++ // "Cannot allocate buffer size %d.\n", headerPtr->n_alloc_len);
++ // svt_ret = EB_ErrorInsufficientResources;
++ // goto failed_init_enc;
++ // }
++ //
++ // svt_ret = eb_svt_enc_stream_header(svt_enc->svt_handle, &headerPtr);
++ // if (svt_ret != EB_ErrorNone) {
++ // av_log(avctx, AV_LOG_ERROR, "Error when build stream header.\n");
++ // av_freep(&headerPtr->p_buffer);
++ // goto failed_init_enc;
++ // }
++ //
++ // avctx->extradata_size = headerPtr->n_filled_len;
++ // avctx->extradata = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
++ // if (!avctx->extradata) {
++ // av_log(avctx, AV_LOG_ERROR,
++ // "Cannot allocate VP9 header of size %d.\n", avctx->extradata_size);
++ // av_freep(&headerPtr->p_buffer);
++ // svt_ret = EB_ErrorInsufficientResources;
++ // goto failed_init_enc;
++ // }
++ // memcpy(avctx->extradata, headerPtr->p_buffer, avctx->extradata_size);
++ //
++ // av_freep(&headerPtr->p_buffer);
++ // }
++ return 0;
++
++//failed_init_enc:
++// eb_deinit_encoder(svt_enc->svt_handle);
++failed_init_handle:
++ eb_vp9_deinit_handle(svt_enc->svt_handle);
++failed:
++ free_buffer(svt_enc);
++ return error_mapping(svt_ret);
++}
++
++static int eb_send_frame(AVCodecContext *avctx, const AVFrame *frame)
++{
++ SvtContext *svt_enc = avctx->priv_data;
++ EbBufferHeaderType *headerPtr = svt_enc->in_buf;
++
++ if (!frame) {
++ if (svt_enc->eos_flag == EOS_REACHED)
++ return 0;
++
++ EbBufferHeaderType headerPtrLast;
++ headerPtrLast.n_alloc_len = 0;
++ headerPtrLast.n_filled_len = 0;
++ headerPtrLast.n_tick_count = 0;
++ headerPtrLast.p_app_private = NULL;
++ headerPtrLast.p_buffer = NULL;
++ headerPtrLast.flags = EB_BUFFERFLAG_EOS;
++
++ eb_vp9_svt_enc_send_picture(svt_enc->svt_handle, &headerPtrLast);
++ svt_enc->eos_flag = EOS_REACHED;
++ av_log(avctx, AV_LOG_DEBUG, "Finish sending frames!!!\n");
++ return 0;
++ }
++
++ read_in_data(&svt_enc->enc_params, frame, headerPtr);
++
++ headerPtr->flags = 0;
++ headerPtr->p_app_private = NULL;
++ headerPtr->pts = frame->pts;
++ switch (frame->pict_type) {
++ case AV_PICTURE_TYPE_I:
++ headerPtr->pic_type = svt_enc->forced_idr > 0 ? EB_IDR_PICTURE : EB_I_PICTURE;
++ break;
++ case AV_PICTURE_TYPE_P:
++ headerPtr->pic_type = EB_P_PICTURE;
++ break;
++ case AV_PICTURE_TYPE_B:
++ headerPtr->pic_type = EB_B_PICTURE;
++ break;
++ default:
++ headerPtr->pic_type = EB_INVALID_PICTURE;
++ break;
++ }
++ eb_vp9_svt_enc_send_picture(svt_enc->svt_handle, headerPtr);
++
++ return 0;
++}
++
++static int is_frame_visible(uint8_t const* ptr, int size) {
++ GetBitContext gb;
++ int ret, visible, profile;
++ if ((ret = init_get_bits8(&gb, ptr, size)) < 0) {
++ return ret;
++ }
++
++ // frame marker
++ get_bits(&gb, 2);
++ profile = get_bits1(&gb);
++ profile |= get_bits1(&gb) << 1;
++
++ // reserved_zero
++ if (profile == 3) profile += get_bits1(&gb); // reserved_zero
++
++ // read show_existing_frame
++ if (get_bits1(&gb)) {
++ // show_existing_frame == 1
++ visible = 1;
++ } else {
++ // show_existing_frame == 0
++ // keyframe (frame_type actually)
++ get_bits1(&gb);
++ // read show_frame
++ visible = get_bits1(&gb) ? 2 : 0;
++ }
++
++ return visible;
++}
++
++static int get_received_frame(SvtContext *svt_enc, AVPacket *pkt) {
++ SvtReceivedFrameStruct* rfs = &svt_enc->received_frames[0];
++
++ if (svt_enc->received_frames_size == 0 || !rfs->ready_flag) {
++ return AVERROR(EAGAIN);
++ }
++
++ pkt->buf = rfs->buf;
++ pkt->data = rfs->buf->data;
++ pkt->dts = rfs->dts;
++ pkt->pts = rfs->pts;
++ pkt->flags = rfs->flags;
++ pkt->size = rfs->size;
++
++ --svt_enc->received_frames_size;
++ for (int i = 0; i < svt_enc->received_frames_size; ++i) {
++ svt_enc->received_frames[i] = svt_enc->received_frames[i + 1];
++ }
++
++ return 0;
++}
++
++static int put_received_frame(AVCodecContext *avctx, uint8_t* data, int size, int keyframe, int64_t dts, int64_t pts) {
++ SvtContext *svt_enc = avctx->priv_data;
++ SvtReceivedFrameStruct* rfs;
++
++ if (svt_enc->received_frames_size == 0 || svt_enc->received_frames[svt_enc->received_frames_size - 1].ready_flag) {
++ ++svt_enc->received_frames_size;
++ if (svt_enc->received_frames_size > RECIVED_FRAMES_MAX_SIZE) {
++ av_log(avctx, AV_LOG_ERROR, "Fail: svt_enc->received_frames_size > RECIVED_FRAMES_MAX_SIZE \n");
++ return AVERROR_BUG;
++ }
++
++ rfs = &svt_enc->received_frames[svt_enc->received_frames_size - 1];
++
++ rfs->buf = av_buffer_pool_get(svt_enc->pool);
++ if (!rfs->buf) {
++ av_log(avctx, AV_LOG_ERROR, "Failed to allocate output packet.\n");
++ return AVERROR(ENOMEM);
++ }
++
++ rfs->size = 0;
++ rfs->flags = 0;
++ rfs->ready_flag = 0;
++ rfs->frames_count = 0;
++ } else {
++ rfs = &svt_enc->received_frames[svt_enc->received_frames_size - 1];
++ }
++
++ rfs->pts = pts;
++ rfs->dts = dts;
++ rfs->flags = (keyframe ? AV_PKT_FLAG_KEY : 0);
++
++ ++rfs->frames_count;
++ if (rfs->frames_count > MAX_VP9_SUPERFRAME_SIZE) {
++ av_log(avctx, AV_LOG_ERROR, "Fail: rfs->frames_count > MAX_VP9_SUPERFRAME_SIZE \n");
++ return AVERROR_BUG;
++ }
++
++ rfs->frames_sizes[rfs->frames_count - 1] = size;
++
++ memcpy(rfs->buf->data + rfs->size, data, size);
++ rfs->size += size;
++
++ int visible = is_frame_visible(data, size);
++ if (visible < 0) {
++ av_log(avctx, AV_LOG_ERROR, "Fail: is_frame_visible \n");
++ return visible;
++ }
++
++
++ rfs->ready_flag = visible;
++
++ if (rfs->ready_flag) {
++ if (rfs->dts <= svt_enc->last_ready_dts) {
++ rfs->dts = svt_enc->last_ready_dts + 1;
++ }
++ svt_enc->last_ready_dts = rfs->dts;
++
++ }
++
++ // add superframe_index if needed
++ if (rfs->ready_flag && rfs->frames_count > 1) {
++ // superframe_header:
++ // 110 - superframe_marker
++ // 11 = 3 = bytes_per_framesize_minus_1 - use 4-bytes size
++ // xxx = frames_in_superframe_minus_1
++ uint8_t header = 0b11011000;
++ header |= (rfs->frames_count - 1) & 0b111;
++
++ uint8_t* ptr = rfs->buf->data + rfs->size;
++
++ ptr[0] = header;
++ ++ptr;
++
++ for (int i = 0; i < rfs->frames_count; ++i) {
++ ptr[0] = (rfs->frames_sizes[i] >> 0) & 0xff;
++ ptr[1] = (rfs->frames_sizes[i] >> 8) & 0xff;
++ ptr[2] = (rfs->frames_sizes[i] >> 16) & 0xff;
++ ptr[3] = (rfs->frames_sizes[i] >> 24) & 0xff;
++
++ ptr += 4;
++ }
++
++ ptr[0] = header;
++ ++ptr;
++
++ rfs->size = ptr - rfs->buf->data;
++ }
++
++ return 0;
++}
++
++static int eb_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
++{
++ SvtContext *svt_enc = avctx->priv_data;
++ EbBufferHeaderType *headerPtr;
++ EbErrorType svt_ret;
++ AVBufferRef *ref;
++ int ret = 0;
++
++ if (get_received_frame(svt_enc, pkt) == 0) {
++ return 0;
++ }
++
++ if (EOS_TOTRIGGER == svt_enc->eos_flag) {
++ pkt = NULL;
++ return AVERROR_EOF;
++ }
++
++ AVFrame *frame = svt_enc->frame;
++ ret = ff_encode_get_frame(avctx, frame);
++ if (ret < 0 && ret != AVERROR_EOF) {
++ return ret;
++ }
++ if (ret == AVERROR_EOF)
++ frame = NULL;
++
++ ret = eb_send_frame(avctx, frame);
++ if (ret < 0)
++ return ret;
++ av_frame_unref(svt_enc->frame);
++
++ for (;;) {
++ svt_ret = eb_vp9_svt_get_packet(svt_enc->svt_handle, &headerPtr, svt_enc->eos_flag);
++ if (svt_ret == EB_NoErrorEmptyQueue) {
++ return AVERROR(EAGAIN);
++ }
++
++ if (EB_BUFFERFLAG_EOS & headerPtr->flags)
++ svt_enc->eos_flag = EOS_TOTRIGGER;
++
++ ret = 0;
++
++ // ignore headerPtr->dts on purpose
++
++ if (headerPtr->flags & EB_BUFFERFLAG_SHOW_EXT) {
++ ret = put_received_frame(avctx, headerPtr->p_buffer, headerPtr->n_filled_len - 4, 0, headerPtr->pts - 3, headerPtr->pts - 3);
++ if (ret != 0) goto end;
++ ret = put_received_frame(avctx, headerPtr->p_buffer + headerPtr->n_filled_len - 4, 1, 0, headerPtr->pts - 2, headerPtr->pts - 2);
++ if (ret != 0) goto end;
++ ret = put_received_frame(avctx, headerPtr->p_buffer + headerPtr->n_filled_len - 3, 1, 0, headerPtr->pts - 1, headerPtr->pts - 1);
++ if (ret != 0) goto end;
++ ret = put_received_frame(avctx, headerPtr->p_buffer + headerPtr->n_filled_len - 2, 1, 0, headerPtr->pts + 0, headerPtr->pts + 0);
++ if (ret != 0) goto end;
++ ret = put_received_frame(avctx, headerPtr->p_buffer + headerPtr->n_filled_len - 1, 1, 0, headerPtr->pts + 1, headerPtr->pts + 1);
++ if (ret != 0) goto end;
++ } else {
++ ret = put_received_frame(avctx, headerPtr->p_buffer, headerPtr->n_filled_len, headerPtr->pic_type == EB_IDR_PICTURE, headerPtr->pts, headerPtr->pts);
++ if (ret != 0) goto end;
++ }
++
++ ret = get_received_frame(svt_enc, pkt);
++
++ end:
++ eb_vp9_svt_release_out_buffer(&headerPtr);
++
++ if (ret == AVERROR(EAGAIN)) {
++ continue;
++ }
++
++ break;
++ }
++
++
++
++ return ret;
++}
++
++static av_cold int eb_enc_close(AVCodecContext *avctx)
++{
++ SvtContext *svt_enc = avctx->priv_data;
++
++ eb_vp9_deinit_encoder(svt_enc->svt_handle);
++ eb_vp9_deinit_handle(svt_enc->svt_handle);
++
++ av_frame_free(&svt_enc->frame);
++
++ free_buffer(svt_enc);
++
++ return 0;
++}
++
++#define OFFSET(x) offsetof(SvtContext, x)
++#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
++static const AVOption options[] = {
++ { "preset", "Encoding preset [1, 1]",
++ OFFSET(enc_mode), AV_OPT_TYPE_INT, { .i64 = 9 }, 0, 9, VE },
++
++ { "level", "Set level (level_idc)", OFFSET(level),
++ AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 0xff, VE, "level" },
++
++#define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
++ { .i64 = value }, 0, 0, VE, "level"
++ { LEVEL("1", 10) },
++ { LEVEL("2", 20) },
++ { LEVEL("2.1", 21) },
++ { LEVEL("3", 30) },
++ { LEVEL("3.1", 31) },
++ { LEVEL("4", 40) },
++ { LEVEL("4.1", 41) },
++ { LEVEL("5", 50) },
++ { LEVEL("5.1", 51) },
++ { LEVEL("5.2", 52) },
++ { LEVEL("6", 60) },
++ { LEVEL("6.1", 61) },
++ { LEVEL("6.2", 62) },
++#undef LEVEL
++
++ { "tune", "Tune mode", OFFSET(tune),
++ AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 2, VE , "tune"},
++ { "vq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "tune" },
++ { "ssim", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "tune" },
++ { "vmaf", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "tune" },
++
++ { "rc", "Bit rate control mode", OFFSET(rc_mode),
++ AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 2, VE , "rc"},
++ { "cqp", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "rc" },
++ { "vbr", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "rc" },
++ { "cbr", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "rc" },
++
++ { "qp", "QP value for intra frames", OFFSET(qp),
++ AV_OPT_TYPE_INT, { .i64 = 32 }, 0, 51, VE },
++
++ { "socket", "Target CPU socket to use. -1 use all available", OFFSET(target_socket),
++ AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
++
++ { "bl_mode", "Random Access Prediction Structure type setting", OFFSET(base_layer_switch_mode),
++ AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
++
++ { "forced-idr", "If forcing keyframes, force them as IDR frames.", OFFSET(forced_idr),
++ AV_OPT_TYPE_BOOL, { .i64 = 0 }, -1, 1, VE },
++
++ {NULL},
++};
++
++static const AVClass class = {
++ .class_name = "libsvt_vp9",
++ .item_name = av_default_item_name,
++ .option = options,
++ .version = LIBAVUTIL_VERSION_INT,
++};
++
++static const FFCodecDefault eb_enc_defaults[] = {
++ { "b", "7M" },
++ { "flags", "-cgop" },
++ { "qmin", "10" },
++ { "qmax", "48" },
++ { NULL },
++};
++
++FFCodec ff_libsvt_vp9_encoder = {
++ .p.name = "libsvt_vp9",
++ .p.long_name = NULL_IF_CONFIG_SMALL("SVT-VP9(Scalable Video Technology for VP9) encoder"),
++ .priv_data_size = sizeof(SvtContext),
++ .p.type = AVMEDIA_TYPE_VIDEO,
++ .p.id = AV_CODEC_ID_VP9,
++ .init = eb_enc_init,
++ FF_CODEC_RECEIVE_PACKET_CB(eb_receive_packet),
++ .close = eb_enc_close,
++ .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AUTO_THREADS,
++ .p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P,
++ AV_PIX_FMT_NONE },
++ .p.priv_class = &class,
++ .defaults = eb_enc_defaults,
++ .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
++ .p.wrapper_name = "libsvt_vp9",
++};
+--
+2.17.1
+
diff --git a/040-ffmpeg-add-av_stream_get_first_dts-for-chromium.patch b/040-ffmpeg-add-av_stream_get_first_dts-for-chromium.patch
new file mode 100644
index 000000000000..83fd707e65d0
--- /dev/null
+++ b/040-ffmpeg-add-av_stream_get_first_dts-for-chromium.patch
@@ -0,0 +1,29 @@
+--- a/libavformat/avformat.h
++++ b/libavformat/avformat.h
+@@ -1128,6 +1128,10 @@ struct AVCodecParserContext *av_stream_get_parser(const AVStream *s);
+ */
+ int64_t av_stream_get_end_pts(const AVStream *st);
+
++// Chromium: We use the internal field first_dts vvv
++int64_t av_stream_get_first_dts(const AVStream *st);
++// Chromium: We use the internal field first_dts ^^^
++
+ #define AV_PROGRAM_RUNNING 1
+
+ /**
+--- a/libavformat/utils.c
++++ b/libavformat/utils.c
+@@ -55,6 +55,13 @@ int ff_unlock_avformat(void)
+ return ff_mutex_unlock(&avformat_mutex) ? -1 : 0;
+ }
+
++// Chromium: We use the internal field first_dts vvv
++int64_t av_stream_get_first_dts(const AVStream *st)
++{
++ return ffstream(st)->first_dts;
++}
++// Chromium: We use the internal field first_dts ^^^
++
+ /* an arbitrarily chosen "sane" max packet size -- 50M */
+ #define SANE_CHUNK_SIZE (50000000)
+
diff --git a/060-ffmpeg-fix-segfault-with-avisynthplus.patch b/060-ffmpeg-fix-segfault-with-avisynthplus.patch
new file mode 100644
index 000000000000..2404112a4236
--- /dev/null
+++ b/060-ffmpeg-fix-segfault-with-avisynthplus.patch
@@ -0,0 +1,11 @@
+--- a/libavformat/avisynth.c
++++ b/libavformat/avisynth.c
+@@ -127,7 +127,7 @@ static av_cold void avisynth_atexit_handler(void);
+
+ static av_cold int avisynth_load_library(void)
+ {
+- avs_library.library = dlopen(AVISYNTH_LIB, RTLD_NOW | RTLD_LOCAL);
++ avs_library.library = dlopen(AVISYNTH_LIB, RTLD_NOW | RTLD_DEEPBIND);
+ if (!avs_library.library)
+ return AVERROR_UNKNOWN;
+
diff --git a/070-ffmpeg-fix-v4l2-memory-leak.patch b/070-ffmpeg-fix-v4l2-memory-leak.patch
new file mode 100644
index 000000000000..2c448137f47b
--- /dev/null
+++ b/070-ffmpeg-fix-v4l2-memory-leak.patch
@@ -0,0 +1,27 @@
+From 30aa0c3f4873a92c5e3da8ba8cf030de56bf4cf7 Mon Sep 17 00:00:00 2001
+From: Zhao Zhili <zhilizhao@tencent.com>
+Date: Wed, 27 Jul 2022 00:32:51 +0800
+Subject: [PATCH] avdevice/v4l2: fix leak of timefilter
+
+Fixes ticket #9844.
+
+Signed-off-by: Zhao Zhili <zhilizhao@tencent.com>
+---
+ libavdevice/v4l2.c | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/libavdevice/v4l2.c b/libavdevice/v4l2.c
+index 5340382d57..be422d7c8c 100644
+--- a/libavdevice/v4l2.c
++++ b/libavdevice/v4l2.c
+@@ -1011,6 +1011,7 @@ static int v4l2_read_close(AVFormatContext *ctx)
+
+ mmap_close(s);
+
++ ff_timefilter_destroy(s->timefilter);
+ v4l2_close(s->fd);
+ return 0;
+ }
+--
+2.25.1
+
diff --git a/080-ffmpeg-vulkan-extensions-names-fixes.patch b/080-ffmpeg-vulkan-extensions-names-fixes.patch
new file mode 100644
index 000000000000..d7ce57350e4e
--- /dev/null
+++ b/080-ffmpeg-vulkan-extensions-names-fixes.patch
@@ -0,0 +1,33 @@
+From eb0455d64690eed0068e5cb202f72ecdf899837c Mon Sep 17 00:00:00 2001
+From: Lynne <dev@lynne.ee>
+Date: Sun, 25 Dec 2022 01:03:30 +0100
+Subject: [PATCH] hwcontext_vulkan: remove optional encode/decode extensions
+ from the list
+
+They're not currently used, so they don't need to be there.
+Vulkan stabilized the decode extensions less than a week ago, and their
+name prefixes were changed from EXT to KHR. It's a bit too soon to be
+depending on it, so rather than bumping, just remove these for now.
+---
+ libavutil/hwcontext_vulkan.c | 8 --------
+ 1 file changed, 8 deletions(-)
+
+diff --git a/libavutil/hwcontext_vulkan.c b/libavutil/hwcontext_vulkan.c
+index f1db1c7291f1..2a9b5f4aac62 100644
+--- a/libavutil/hwcontext_vulkan.c
++++ b/libavutil/hwcontext_vulkan.c
+@@ -358,14 +358,6 @@ static const VulkanOptExtension optional_device_exts[] = {
+ { VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME, FF_VK_EXT_EXTERNAL_WIN32_MEMORY },
+ { VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME, FF_VK_EXT_EXTERNAL_WIN32_SEM },
+ #endif
+-
+- /* Video encoding/decoding */
+- { VK_KHR_VIDEO_QUEUE_EXTENSION_NAME, FF_VK_EXT_NO_FLAG },
+- { VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME, FF_VK_EXT_NO_FLAG },
+- { VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME, FF_VK_EXT_NO_FLAG },
+- { VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME, FF_VK_EXT_NO_FLAG },
+- { VK_EXT_VIDEO_DECODE_H264_EXTENSION_NAME, FF_VK_EXT_NO_FLAG },
+- { VK_EXT_VIDEO_DECODE_H265_EXTENSION_NAME, FF_VK_EXT_NO_FLAG },
+ };
+
+ /* Converts return values to strings */
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 000000000000..b0bb658ca78c
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,9 @@
+This software is nonfree and unredistributable.
+
+The end-user must compile this software for himself in order to be allowed to use it.
+
+This software cannot be redistributed.
+
+This software cannot be used commercially.
+
+Due to the libraries used to compile this software, the resulting binaries and libraries are under a complex and restrictive license mix.
diff --git a/PKGBUILD b/PKGBUILD
new file mode 100644
index 000000000000..5ff3f47946bb
--- /dev/null
+++ b/PKGBUILD
@@ -0,0 +1,220 @@
+# Maintainer Denis Benato <benato dot denis96 [at] gmail dot com>
+# Original (ffmpeg-amd-full): Nathaniel Chin <thegamingorangutans+aur at gmail.com>
+# Original (ffmpeg-full): Daniel Bermond <dbermond@archlinux.org> > https://aur.archlinux.org/packages/ffmpeg-full
+# Contributor: Marko Korhonen <reekymarko at reekynet.com>
+# Contributor: Bruno Filipe < gmail-com: bmilreu >
+
+pkgname=ffmpeg-nonvidia
+pkgver=5.1.2
+pkgrel=2
+pkgdesc='Complete solution to record, convert and stream audio and video (all possible features for AMD and no nVidia related stuff)'
+arch=('x86_64')
+url='https://www.ffmpeg.org/'
+license=('custom: nonfree and unredistributable')
+depends=('alsa-lib' 'aom' 'aribb24' 'avisynthplus' 'bzip2' 'celt' 'codec2'
+ 'dav1d' 'fontconfig' 'freetype2' 'fribidi' 'glslang' 'frei0r-plugins' 'gmp'
+ 'gnutls' 'gsm' 'jack' 'kvazaar' 'ladspa' 'lame' 'libavc1394'
+ 'lcms2' 'lensfun-git' 'libass' 'libbluray' 'libbs2b' 'libcaca' 'libcdio-paranoia'
+ 'libdc1394' 'libdrm' 'libfdk-aac' 'libgme' 'libgl' 'libgcrypt' 'libiec61883'
+ 'libilbc' 'libjxl' 'libmodplug' 'libmysofa' 'libomxil-bellagio' 'libplacebo'
+ 'libpulse' 'librabbitmq-c' 'librsvg' 'libssh' 'libsoxr' 'libtheora' 'libva'
+ 'libvdpau' 'libvorbis' 'libvpx' 'libx11' 'libxcb' 'libxext' 'libxml2' 'libxv'
+ 'libwebp' 'lilv' 'lv2' 'ocl-icd' 'openal' 'opencore-amr' 'openh264' 'openjpeg2'
+ 'libopenmpt' 'opus' 'rav1e' 'rubberband' 'rtmpdump' 'sdl2' 'smbclient' 'snappy'
+ 'sndio' 'speex' 'spirv-tools' 'srt' 'svt-av1' 'svt-hevc' 'svt-vp9' 'tesseract'
+ 'twolame' 'v4l-utils' 'vapoursynth' 'vid.stab' 'vmaf' 'vulkan-icd-loader' 'x264'
+ 'x265' 'xvidcore' 'xz' 'zeromq' 'zimg' 'zlib' 'zvbi'
+ 'chromaprint-fftw' 'davs2' 'flite1' 'libklvanc-git' 'librist' 'pocketsphinx'
+ 'shine' 'uavs3d-git' 'vo-amrwbenc' 'xavs' 'xavs2')
+makedepends=('clang' 'amf-headers' 'nasm' 'opencl-headers'
+ 'vulkan-headers' 'decklink-sdk')
+
+provides=('libavcodec.so' 'libavdevice.so' 'libavfilter.so' 'libavformat.so'
+ 'libavutil.so' 'libpostproc.so' 'libswscale.so' 'libswresample.so'
+ 'ffmpeg' 'ffmpeg-full')
+conflicts=('ffmpeg')
+_svt_hevc_ver='b62f72e752243cee4104cfb41dc7ee409d3ac3e9'
+_svt_vp9_ver='d9ef3cc13159143b9afc776c04f67cdfa6284046'
+source=("https://ffmpeg.org/releases/ffmpeg-${pkgver}.tar.xz"{,.asc}
+ "010-ffmpeg-add-svt-hevc-g${_svt_hevc_ver:0:7}.patch"::"https://raw.githubusercontent.com/OpenVisualCloud/SVT-HEVC/${_svt_hevc_ver}/ffmpeg_plugin/master-0001-lavc-svt_hevc-add-libsvt-hevc-encoder-wrapper.patch"
+ #"020-ffmpeg-add-svt-hevc-docs-g${_svt_hevc_ver:0:7}.patch"::"https://raw.githubusercontent.com/OpenVisualCloud/SVT-HEVC/${_svt_hevc_ver}/ffmpeg_plugin/0002-doc-Add-libsvt_hevc-encoder-docs.patch"
+ "030-ffmpeg-add-svt-vp9-g${_svt_vp9_ver:0:7}.patch"::"https://raw.githubusercontent.com/OpenVisualCloud/SVT-VP9/${_svt_vp9_ver}/ffmpeg_plugin/master-0001-Add-ability-for-ffmpeg-to-run-svt-vp9.patch"
+ '040-ffmpeg-add-av_stream_get_first_dts-for-chromium.patch'
+ '060-ffmpeg-fix-segfault-with-avisynthplus.patch'
+ '070-ffmpeg-fix-v4l2-memory-leak.patch'::'https://git.ffmpeg.org/gitweb/ffmpeg.git/patch/30aa0c3f4873a92c5e3da8ba8cf030de56bf4cf7'
+ '080-ffmpeg-vulkan-extensions-names-fixes.patch'
+ 'LICENSE')
+sha256sums=('619e706d662c8420859832ddc259cd4d4096a48a2ce1eefd052db9e440eef3dc'
+ 'SKIP'
+ '4da3826aa370572273ef9fb4c0bf2c93a840595b07a671a0412ad0dc9ed8d689'
+ 'e310eedb3dc88c8ad6ffcd6cb6bde1f593ded330ea99b0356724c9d22bcfde4c'
+ '2df82046908015bf26bc1303275cf52ba01fa380029a54ea6415373e389e423c'
+ 'b1d68f626168f2409a4b0987acf5b208e7ced2ddab49b11990a10f458d377e9a'
+ '9e4e290378028cd4474c36d3e3a25f77d4f40424dbd3115632e20c5734b50979'
+ 'e570c823f4a91699e0fd8eea9e07353e76a5e4156f7af8c2b3d5f65aa7f41d5f'
+ '04a7176400907fd7db0d69116b99de49e582a6e176b3bfb36a03e50a4cb26a36'
+)
+validpgpkeys=('FCF986EA15E6E293A5644F10B4322F04D67658D8')
+
+prepare() {
+ rm -f "ffmpeg-${pkgver}/libavcodec/"libsvt_{hevc,vp9}.c
+ patch -d "ffmpeg-${pkgver}" -Np1 -i "${srcdir}/010-ffmpeg-add-svt-hevc-g${_svt_hevc_ver:0:7}.patch"
+ #patch -d "ffmpeg-${pkgver}" -Np1 -i "${srcdir}/020-ffmpeg-add-svt-hevc-docs-g${_svt_hevc_ver:0:7}.patch"
+ patch -d "ffmpeg-${pkgver}" -Np1 -i "${srcdir}/030-ffmpeg-add-svt-vp9-g${_svt_vp9_ver:0:7}.patch"
+ patch -d "ffmpeg-${pkgver}" -Np1 -i "${srcdir}/040-ffmpeg-add-av_stream_get_first_dts-for-chromium.patch"
+ patch -d "ffmpeg-${pkgver}" -Np1 -i "${srcdir}/060-ffmpeg-fix-segfault-with-avisynthplus.patch"
+ patch -d "ffmpeg-${pkgver}" -Np1 -i "${srcdir}/070-ffmpeg-fix-v4l2-memory-leak.patch"
+ patch -d "ffmpeg-${pkgver}" -Np1 -i "${srcdir}/080-ffmpeg-vulkan-extensions-names-fixes.patch"
+}
+
+build() {
+ cd "ffmpeg-${pkgver}"
+ printf '%s\n' ' -> Running ffmpeg configure script...'
+
+ ./configure \
+ --prefix='/usr' \
+ --enable-lto \
+ --cc=$CC \
+ --cxx=$CXX \
+ --disable-rpath \
+ --enable-gpl \
+ --enable-version3 \
+ --enable-nonfree \
+ --enable-shared \
+ --disable-static \
+ --disable-stripping \
+ --enable-gray \
+ \
+ --enable-alsa \
+ --enable-avisynth \
+ --enable-bzlib \
+ --enable-chromaprint \
+ --enable-frei0r \
+ --enable-gcrypt \
+ --enable-gmp \
+ --enable-gnutls \
+ --enable-iconv \
+ --enable-ladspa \
+ --enable-lcms2 \
+ --enable-libaom \
+ --enable-libaribb24 \
+ --enable-libass \
+ --enable-libbluray \
+ --enable-libbs2b \
+ --enable-libcaca \
+ --enable-libcelt \
+ --enable-libcdio \
+ --enable-libcodec2 \
+ --enable-libdav1d \
+ --enable-libdavs2 \
+ --enable-libdc1394 \
+ --enable-libfdk-aac \
+ --enable-libflite \
+ --enable-fontconfig \
+ --enable-libfreetype \
+ --enable-libfribidi \
+ --enable-libglslang \
+ --enable-libgme \
+ --enable-libgsm \
+ --enable-libiec61883 \
+ --enable-libilbc \
+ --enable-libjack \
+ --enable-libjxl \
+ --enable-libklvanc \
+ --enable-libkvazaar \
+ --enable-liblensfun \
+ --enable-libmodplug \
+ --enable-libmp3lame \
+ --enable-libopencore-amrnb \
+ --enable-libopencore-amrwb \
+ --disable-libopencv \
+ --enable-libopenh264 \
+ --enable-libopenjpeg \
+ --enable-libopenmpt \
+ --disable-libopenvino \
+ --enable-libopus \
+ --enable-libplacebo \
+ --enable-libpulse \
+ --enable-librabbitmq \
+ --enable-librav1e \
+ --enable-librist \
+ --enable-librsvg \
+ --enable-librubberband \
+ --enable-librtmp \
+ --enable-libshine \
+ --enable-libsmbclient \
+ --enable-libsnappy \
+ --enable-libsoxr \
+ --enable-libspeex \
+ --enable-libsrt \
+ --enable-libssh \
+ --enable-libsvtav1 \
+ --enable-libsvthevc \
+ --enable-libsvtvp9 \
+ --disable-libtensorflow \
+ --enable-libtesseract \
+ --enable-libtheora \
+ --disable-libtls \
+ --enable-libtwolame \
+ --enable-libuavs3d \
+ --enable-libv4l2 \
+ --enable-libvidstab \
+ --enable-libvmaf \
+ --enable-libvo-amrwbenc \
+ --enable-libvorbis \
+ --enable-libvpx \
+ --enable-libwebp \
+ --enable-libx264 \
+ --enable-libx265 \
+ --enable-libxavs \
+ --enable-libxavs2 \
+ --enable-libxcb \
+ --enable-libxcb-shm \
+ --enable-libxcb-xfixes \
+ --enable-libxcb-shape \
+ --enable-libxvid \
+ --enable-libxml2 \
+ --enable-libzimg \
+ --enable-libzmq \
+ --enable-libzvbi \
+ --enable-lv2 \
+ --enable-lzma \
+ --enable-decklink \
+ --disable-mbedtls \
+ --enable-libmysofa \
+ --enable-openal \
+ --enable-opencl \
+ --enable-opengl \
+ --disable-openssl \
+ --enable-pocketsphinx \
+ --enable-sndio \
+ --enable-sdl2 \
+ --enable-vapoursynth \
+ --enable-vulkan \
+ --enable-xlib \
+ --enable-zlib \
+ \
+ --enable-amf \
+ --disable-cuda-nvcc \
+ --disable-cuda-llvm \
+ --disable-cuvid \
+ --disable-ffnvcodec \
+ --enable-libdrm \
+ --disable-libmfx \
+ --disable-libnpp \
+ --disable-nvdec \
+ --disable-nvenc \
+ --enable-omx \
+ --disable-rkmpp \
+ --enable-v4l2-m2m \
+ --enable-vaapi \
+ --enable-vdpau
+ make
+ make tools/qt-faststart
+}
+
+package() {
+ make -C "ffmpeg-${pkgver}" DESTDIR="$pkgdir" install
+ install -D -m755 "ffmpeg-${pkgver}/tools/qt-faststart" -t "${pkgdir}/usr/bin"
+ install -D -m644 LICENSE -t "${pkgdir}/usr/share/licenses/${pkgname}"
+}