[FFmpeg-devel] [PATCH v4 1/5] avfilter/vf_yadif_cuda: simplify filter definition

[FFmpeg-devel] [PATCH v4 1/5] avfilter/vf_yadif_cuda: simplify filter definition

[Aman Karmani]

From: Aman Karmani <aman@tmm1.net>

Signed-off-by: Aman Karmani <aman@tmm1.net>
Signed-off-by: Philip Langdale <philipl@overt.org>
---
 libavfilter/vf_yadif_cuda.c | 19 +------------------
 1 file changed, 1 insertion(+), 18 deletions(-)

diff --git a/libavfilter/vf_yadif_cuda.c b/libavfilter/vf_yadif_cuda.c
index da1ab5a8ff..685b8a2035 100644
--- a/libavfilter/vf_yadif_cuda.c
+++ b/libavfilter/vf_yadif_cuda.c
@@ -212,23 +212,6 @@ static av_cold void deint_cuda_uninit(AVFilterContext *ctx)
     s->input_frames = NULL;
 }
 
-static int deint_cuda_query_formats(AVFilterContext *ctx)
-{
-    enum AVPixelFormat pix_fmts[] = {
-        AV_PIX_FMT_CUDA, AV_PIX_FMT_NONE,
-    };
-    int ret;
-
-    if ((ret = ff_formats_ref(ff_make_format_list(pix_fmts),
-                              &ctx->inputs[0]->outcfg.formats)) < 0)
-        return ret;
-    if ((ret = ff_formats_ref(ff_make_format_list(pix_fmts),
-                              &ctx->outputs[0]->incfg.formats)) < 0)
-        return ret;
-
-    return 0;
-}
-
 static int config_input(AVFilterLink *inlink)
 {
     AVFilterContext *ctx = inlink->dst;
@@ -380,9 +363,9 @@ const AVFilter ff_vf_yadif_cuda = {
     .priv_size      = sizeof(DeintCUDAContext),
     .priv_class     = &yadif_cuda_class,
     .uninit         = deint_cuda_uninit,
+    FILTER_SINGLE_PIXFMT(AV_PIX_FMT_CUDA),
     FILTER_INPUTS(deint_cuda_inputs),
     FILTER_OUTPUTS(deint_cuda_outputs),
-    FILTER_QUERY_FUNC(deint_cuda_query_formats),
     .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
     .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
 };
-- 
2.33.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH v4 2/5] build: detect Metal.framework and build .metal files

[Aman Karmani]

From: Aman Karmani <aman@tmm1.net>

Reviewed-by: Ridley Combs <rcombs@rcombs.me>
Signed-off-by: Aman Karmani <aman@tmm1.net>
---
 .gitignore         |  3 +++
 configure          | 12 +++++++++++-
 ffbuild/common.mak |  9 +++++++++
 3 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index 9ed24b542e..1a5bb29ad5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -19,6 +19,9 @@
 *.swp
 *.ver
 *.version
+*.metal.air
+*.metallib
+*.metallib.c
 *.ptx
 *.ptx.c
 *.ptx.gz
diff --git a/configure b/configure
index 5fffcb8afe..32a39f5f5b 100755
--- a/configure
+++ b/configure
@@ -309,6 +309,7 @@ External library support:
                            if openssl, gnutls or libtls is not used [no]
   --enable-mediacodec      enable Android MediaCodec support [no]
   --enable-mediafoundation enable encoding via MediaFoundation [auto]
+  --disable-metal          disable Apple Metal framework [autodetect]
   --enable-libmysofa       enable libmysofa, needed for sofalizer filter [no]
   --enable-openal          enable OpenAL 1.1 capture support [no]
   --enable-opencl          enable OpenCL processing [no]
@@ -382,6 +383,8 @@ Toolchain options:
   --dep-cc=DEPCC           use dependency generator DEPCC [$cc_default]
   --nvcc=NVCC              use Nvidia CUDA compiler NVCC or clang [$nvcc_default]
   --ld=LD                  use linker LD [$ld_default]
+  --metalcc=METALCC        use metal compiler METALCC [$metalcc_default]
+  --metallib=METALLIB      use metal linker METALLIB [$metallib_default]
   --pkg-config=PKGCONFIG   use pkg-config tool PKGCONFIG [$pkg_config_default]
   --pkg-config-flags=FLAGS pass additional flags to pkgconf []
   --ranlib=RANLIB          use ranlib RANLIB [$ranlib_default]
@@ -2564,6 +2567,8 @@ CMDLINE_SET="
     ln_s
     logfile
     malloc_prefix
+    metalcc
+    metallib
     nm
     optflags
     nvcc
@@ -3835,6 +3840,8 @@ host_cc_default="gcc"
 doxygen_default="doxygen"
 install="install"
 ln_s_default="ln -s -f"
+metalcc_default="xcrun metal"
+metallib_default="xcrun metallib"
 nm_default="nm -g"
 pkg_config_default=pkg-config
 ranlib_default="ranlib"
@@ -4435,7 +4442,7 @@ if enabled cuda_nvcc; then
 fi
 
 set_default arch cc cxx doxygen pkg_config ranlib strip sysinclude \
-    target_exec x86asmexe
+    target_exec x86asmexe metalcc metallib
 enabled cross_compile || host_cc_default=$cc
 set_default host_cc
 
@@ -6326,6 +6333,7 @@ check_apple_framework CoreFoundation
 check_apple_framework CoreMedia
 check_apple_framework CoreVideo
 check_apple_framework CoreAudio
+check_apple_framework Metal
 
 enabled avfoundation && {
     disable coregraphics applicationservices
@@ -7620,6 +7628,8 @@ ARFLAGS=$arflags
 AR_O=$ar_o
 AR_CMD=$ar
 NM_CMD=$nm
+METALCC=$metalcc
+METALLIB=$metallib
 RANLIB=$ranlib
 STRIP=$strip
 STRIPTYPE=$striptype
diff --git a/ffbuild/common.mak b/ffbuild/common.mak
index 0eb831d434..e79b509425 100644
--- a/ffbuild/common.mak
+++ b/ffbuild/common.mak
@@ -112,6 +112,15 @@ COMPILE_LASX = $(call COMPILE,CC,LASXFLAGS)
 $(BIN2CEXE): ffbuild/bin2c_host.o
 	$(HOSTLD) $(HOSTLDFLAGS) $(HOSTLD_O) $^ $(HOSTEXTRALIBS)
 
+%.metal.air: %.metal
+	$(METALCC) $(patsubst $(SRC_PATH)/%,$(SRC_LINK)/%,$<) -o $@
+
+%.metallib: %.metal.air
+	$(METALLIB) --split-module-without-linking $(patsubst $(SRC_PATH)/%,$(SRC_LINK)/%,$<) -o $@
+
+%.metallib.c: %.metallib $(BIN2CEXE)
+	$(BIN2C) $(patsubst $(SRC_PATH)/%,$(SRC_LINK)/%,$<) $@ $(subst .,_,$(basename $(notdir $@)))
+
 %.ptx: %.cu $(SRC_PATH)/compat/cuda/cuda_runtime.h
 	$(COMPILE_NVCC)
 
-- 
2.33.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH v4 3/5] avutil: add obj-c helpers into header-only include

[Aman Karmani]

From: Aman Karmani <aman@tmm1.net>

Reviewed-by: Ridley Combs <rcombs@rcombs.me>
Signed-off-by: Aman Karmani <aman@tmm1.net>
---
 libavutil/objc.h | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 libavutil/objc.h

diff --git a/libavutil/objc.h b/libavutil/objc.h
new file mode 100644
index 0000000000..0db993f716
--- /dev/null
+++ b/libavutil/objc.h
@@ -0,0 +1,32 @@
+/*
+ * 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVUTIL_OBJC_H
+#define AVUTIL_OBJC_H
+
+#include <Foundation/Foundation.h>
+
+static inline void ff_objc_release(NSObject **obj)
+{
+    if (*obj) {
+        [*obj release];
+        *obj = nil;
+    }
+}
+
+#endif /* AVUTIL_OBJC_H */
-- 
2.33.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

Re: [FFmpeg-devel] [PATCH v4 3/5] avutil: add obj-c helpers into header-only include

[James Almer]

On 12/17/2021 5:04 PM, Aman Karmani wrote:
> From: Aman Karmani <aman@tmm1.net>
> 
> Reviewed-by: Ridley Combs <rcombs@rcombs.me>
> Signed-off-by: Aman Karmani <aman@tmm1.net>
> ---
>   libavutil/objc.h | 32 ++++++++++++++++++++++++++++++++
>   1 file changed, 32 insertions(+)
>   create mode 100644 libavutil/objc.h
> 
> diff --git a/libavutil/objc.h b/libavutil/objc.h
> new file mode 100644
> index 0000000000..0db993f716
> --- /dev/null
> +++ b/libavutil/objc.h
> @@ -0,0 +1,32 @@
> +/*
> + * 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 FFmpeg; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + */
> +
> +#ifndef AVUTIL_OBJC_H
> +#define AVUTIL_OBJC_H
> +
> +#include <Foundation/Foundation.h>
> +
> +static inline void ff_objc_release(NSObject **obj)
> +{
> +    if (*obj) {
> +        [*obj release];
> +        *obj = nil;
> +    }
> +}
> +
> +#endif /* AVUTIL_OBJC_H */

This breaks checkheaders. It should be added to SKIPHEADERS with the 
corresponding check.

Also, why is this in lavu if it's ultimately only used in lavfi? And 
does it need to be a separate header at all? It's apparently not even C.
_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

Re: [FFmpeg-devel] [PATCH v4 3/5] avutil: add obj-c helpers into header-only include

[Aman Karmani]

On Sun, Dec 19, 2021 at 9:09 AM James Almer <jamrial@gmail.com> wrote:

> On 12/17/2021 5:04 PM, Aman Karmani wrote:
> > From: Aman Karmani <aman@tmm1.net>
> >
> > Reviewed-by: Ridley Combs <rcombs@rcombs.me>
> > Signed-off-by: Aman Karmani <aman@tmm1.net>
> > ---
> >   libavutil/objc.h | 32 ++++++++++++++++++++++++++++++++
> >   1 file changed, 32 insertions(+)
> >   create mode 100644 libavutil/objc.h
> >
> > diff --git a/libavutil/objc.h b/libavutil/objc.h
> > new file mode 100644
> > index 0000000000..0db993f716
> > --- /dev/null
> > +++ b/libavutil/objc.h
> > @@ -0,0 +1,32 @@
> > +/*
> > + * 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 FFmpeg; if not, write to the Free Software
> > + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
> 02110-1301 USA
> > + */
> > +
> > +#ifndef AVUTIL_OBJC_H
> > +#define AVUTIL_OBJC_H
> > +
> > +#include <Foundation/Foundation.h>
> > +
> > +static inline void ff_objc_release(NSObject **obj)
> > +{
> > +    if (*obj) {
> > +        [*obj release];
> > +        *obj = nil;
> > +    }
> > +}
> > +
> > +#endif /* AVUTIL_OBJC_H */
>
> This breaks checkheaders. It should be added to SKIPHEADERS with the
> corresponding check.
>

Sorry, will fix.


>
> Also, why is this in lavu if it's ultimately only used in lavfi? And
> does it need to be a separate header at all? It's apparently not even C.
>

It is a generic helper requested by rcombs. I think the plan is to reuse it
in other filters/decoders/encoders written in obj-c.

One of the reasons is becausing calling `[nil release]` can crash.

You're right that it is not C, its obj-c and that's why it was simpler to
have it be an include only header. I'm not sure if using a different
extension would have been preferred.

Aman


> _______________________________________________
> ffmpeg-devel mailing list
> ffmpeg-devel@ffmpeg.org
> https://ffmpeg.org/mailman/listinfo/ffmpeg-devel
>
> To unsubscribe, visit link above, or email
> ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".
>
_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

Re: [FFmpeg-devel] [PATCH v4 3/5] avutil: add obj-c helpers into header-only include

[Marvin Scholz]

On 19 Dec 2021, at 18:35, Aman Karmani wrote:

> On Sun, Dec 19, 2021 at 9:09 AM James Almer <jamrial@gmail.com> wrote:
>
>> On 12/17/2021 5:04 PM, Aman Karmani wrote:
>>> From: Aman Karmani <aman@tmm1.net>
>>>
>>> Reviewed-by: Ridley Combs <rcombs@rcombs.me>
>>> Signed-off-by: Aman Karmani <aman@tmm1.net>
>>> ---
>>>   libavutil/objc.h | 32 ++++++++++++++++++++++++++++++++
>>>   1 file changed, 32 insertions(+)
>>>   create mode 100644 libavutil/objc.h
>>>
>>> diff --git a/libavutil/objc.h b/libavutil/objc.h
>>> new file mode 100644
>>> index 0000000000..0db993f716
>>> --- /dev/null
>>> +++ b/libavutil/objc.h
>>> @@ -0,0 +1,32 @@
>>> +/*
>>> + * 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 FFmpeg; if not, write to the Free Software
>>> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
>> 02110-1301 USA
>>> + */
>>> +
>>> +#ifndef AVUTIL_OBJC_H
>>> +#define AVUTIL_OBJC_H
>>> +
>>> +#include <Foundation/Foundation.h>
>>> +
>>> +static inline void ff_objc_release(NSObject **obj)
>>> +{
>>> +    if (*obj) {
>>> +        [*obj release];
>>> +        *obj = nil;
>>> +    }
>>> +}
>>> +
>>> +#endif /* AVUTIL_OBJC_H */
>>
>> This breaks checkheaders. It should be added to SKIPHEADERS with the
>> corresponding check.
>>
>
> Sorry, will fix.
>
>
>>
>> Also, why is this in lavu if it's ultimately only used in lavfi? And
>> does it need to be a separate header at all? It's apparently not even C.
>>
>
> It is a generic helper requested by rcombs. I think the plan is to reuse it
> in other filters/decoders/encoders written in obj-c.
>
> One of the reasons is becausing calling `[nil release]` can crash.

That's not true, dispatching a message to nil in Objective-C has no effect.
I don't really see the benefit of this helper, personally.

>
> You're right that it is not C, its obj-c and that's why it was simpler to
> have it be an include only header. I'm not sure if using a different
> extension would have been preferred.
>
> Aman
>
>
>> _______________________________________________
>> ffmpeg-devel mailing list
>> ffmpeg-devel@ffmpeg.org
>> https://ffmpeg.org/mailman/listinfo/ffmpeg-devel
>>
>> To unsubscribe, visit link above, or email
>> ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".
>>
> _______________________________________________
> ffmpeg-devel mailing list
> ffmpeg-devel@ffmpeg.org
> https://ffmpeg.org/mailman/listinfo/ffmpeg-devel
>
> To unsubscribe, visit link above, or email
> ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".
_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

Re: [FFmpeg-devel] [PATCH v4 3/5] avutil: add obj-c helpers into header-only include

[Ridley Combs]

> On Dec 19, 2021, at 12:03, Marvin Scholz <epirat07@gmail.com> wrote:
> 
> 
> 
> On 19 Dec 2021, at 18:35, Aman Karmani wrote:
> 
>> On Sun, Dec 19, 2021 at 9:09 AM James Almer <jamrial@gmail.com> wrote:
>> 
>>> On 12/17/2021 5:04 PM, Aman Karmani wrote:
>>>> From: Aman Karmani <aman@tmm1.net>
>>>> 
>>>> Reviewed-by: Ridley Combs <rcombs@rcombs.me>
>>>> Signed-off-by: Aman Karmani <aman@tmm1.net>
>>>> ---
>>>>  libavutil/objc.h | 32 ++++++++++++++++++++++++++++++++
>>>>  1 file changed, 32 insertions(+)
>>>>  create mode 100644 libavutil/objc.h
>>>> 
>>>> diff --git a/libavutil/objc.h b/libavutil/objc.h
>>>> new file mode 100644
>>>> index 0000000000..0db993f716
>>>> --- /dev/null
>>>> +++ b/libavutil/objc.h
>>>> @@ -0,0 +1,32 @@
>>>> +/*
>>>> + * 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 FFmpeg; if not, write to the Free Software
>>>> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
>>> 02110-1301 USA
>>>> + */
>>>> +
>>>> +#ifndef AVUTIL_OBJC_H
>>>> +#define AVUTIL_OBJC_H
>>>> +
>>>> +#include <Foundation/Foundation.h>
>>>> +
>>>> +static inline void ff_objc_release(NSObject **obj)
>>>> +{
>>>> +    if (*obj) {
>>>> +        [*obj release];
>>>> +        *obj = nil;
>>>> +    }
>>>> +}
>>>> +
>>>> +#endif /* AVUTIL_OBJC_H */
>>> 
>>> This breaks checkheaders. It should be added to SKIPHEADERS with the
>>> corresponding check.
>>> 
>> 
>> Sorry, will fix.
>> 
>> 
>>> 
>>> Also, why is this in lavu if it's ultimately only used in lavfi? And
>>> does it need to be a separate header at all? It's apparently not even C.
>>> 
>> 
>> It is a generic helper requested by rcombs. I think the plan is to reuse it
>> in other filters/decoders/encoders written in obj-c.
>> 
>> One of the reasons is becausing calling `[nil release]` can crash.
> 
> That's not true, dispatching a message to nil in Objective-C has no effect.
> I don't really see the benefit of this helper, personally.

The main point is the same as av_freep: it combines releasing the memory and nulling out the pointer into a single call, so we can't end up with dangling pointers by mistake.

> 
>> 
>> You're right that it is not C, its obj-c and that's why it was simpler to
>> have it be an include only header. I'm not sure if using a different
>> extension would have been preferred.
>> 
>> Aman
>> 
>> 
>>> _______________________________________________
>>> ffmpeg-devel mailing list
>>> ffmpeg-devel@ffmpeg.org
>>> https://ffmpeg.org/mailman/listinfo/ffmpeg-devel
>>> 
>>> To unsubscribe, visit link above, or email
>>> ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".
>>> 
>> _______________________________________________
>> ffmpeg-devel mailing list
>> ffmpeg-devel@ffmpeg.org <mailto:ffmpeg-devel@ffmpeg.org>
>> https://ffmpeg.org/mailman/listinfo/ffmpeg-devel <https://ffmpeg.org/mailman/listinfo/ffmpeg-devel>
>> 
>> To unsubscribe, visit link above, or email
>> ffmpeg-devel-request@ffmpeg.org <mailto:ffmpeg-devel-request@ffmpeg.org> with subject "unsubscribe".

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH v4 4/5] avfilter: add metal utilities

[Aman Karmani]

From: Aman Karmani <aman@tmm1.net>

Reviewed-by: Ridley Combs <rcombs@rcombs.me>
Signed-off-by: Aman Karmani <aman@tmm1.net>
---
 libavfilter/metal/utils.h | 35 +++++++++++++++++++
 libavfilter/metal/utils.m | 73 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 108 insertions(+)
 create mode 100644 libavfilter/metal/utils.h
 create mode 100644 libavfilter/metal/utils.m

diff --git a/libavfilter/metal/utils.h b/libavfilter/metal/utils.h
new file mode 100644
index 0000000000..bd0319f63c
--- /dev/null
+++ b/libavfilter/metal/utils.h
@@ -0,0 +1,35 @@
+/*
+ * 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVFILTER_METAL_UTILS_H
+#define AVFILTER_METAL_UTILS_H
+
+#include <Metal/Metal.h>
+#include <CoreVideo/CoreVideo.h>
+
+void ff_metal_compute_encoder_dispatch(id<MTLDevice> device,
+                                       id<MTLComputePipelineState> pipeline,
+                                       id<MTLComputeCommandEncoder> encoder,
+                                       NSUInteger width, NSUInteger height);
+
+CVMetalTextureRef ff_metal_texture_from_pixbuf(void *avclass,
+                                               CVMetalTextureCacheRef textureCache,
+                                               CVPixelBufferRef pixbuf,
+                                               int plane,
+                                               MTLPixelFormat format);
+#endif /* AVFILTER_METAL_UTILS_H */
diff --git a/libavfilter/metal/utils.m b/libavfilter/metal/utils.m
new file mode 100644
index 0000000000..759ebedfba
--- /dev/null
+++ b/libavfilter/metal/utils.m
@@ -0,0 +1,73 @@
+/*
+ * 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libavutil/log.h"
+#include <libavfilter/metal/utils.h>
+
+void ff_metal_compute_encoder_dispatch(id<MTLDevice> device,
+                                       id<MTLComputePipelineState> pipeline,
+                                       id<MTLComputeCommandEncoder> encoder,
+                                       NSUInteger width, NSUInteger height)
+{
+    [encoder setComputePipelineState:pipeline];
+    NSUInteger w = pipeline.threadExecutionWidth;
+    NSUInteger h = pipeline.maxTotalThreadsPerThreadgroup / w;
+    MTLSize threadsPerThreadgroup = MTLSizeMake(w, h, 1);
+    BOOL fallback = YES;
+    if (@available(macOS 10.15, iOS 11, tvOS 14.5, *)) {
+        if ([device supportsFamily:MTLGPUFamilyCommon3]) {
+            MTLSize threadsPerGrid = MTLSizeMake(width, height, 1);
+            [encoder dispatchThreads:threadsPerGrid threadsPerThreadgroup:threadsPerThreadgroup];
+            fallback = NO;
+        }
+    }
+    if (fallback) {
+        MTLSize threadgroups = MTLSizeMake((width + w - 1) / w,
+                                           (height + h - 1) / h,
+                                           1);
+        [encoder dispatchThreadgroups:threadgroups threadsPerThreadgroup:threadsPerThreadgroup];
+    }
+}
+
+CVMetalTextureRef ff_metal_texture_from_pixbuf(void *ctx,
+                                               CVMetalTextureCacheRef textureCache,
+                                               CVPixelBufferRef pixbuf,
+                                               int plane,
+                                               MTLPixelFormat format)
+{
+    CVMetalTextureRef tex = NULL;
+    CVReturn ret;
+
+    ret = CVMetalTextureCacheCreateTextureFromImage(
+        NULL,
+        textureCache,
+        pixbuf,
+        NULL,
+        format,
+        CVPixelBufferGetWidthOfPlane(pixbuf, plane),
+        CVPixelBufferGetHeightOfPlane(pixbuf, plane),
+        plane,
+        &tex
+    );
+    if (ret != kCVReturnSuccess) {
+        av_log(ctx, AV_LOG_ERROR, "Failed to create CVMetalTexture from image: %d\n", ret);
+        return NULL;
+    }
+
+    return tex;
+}
-- 
2.33.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH v4 5/5] avfilter: add vf_yadif_videotoolbox

[Aman Karmani]

From: Aman Karmani <aman@tmm1.net>

deinterlaces CVPixelBuffers, i.e. AV_PIX_FMT_VIDEOTOOLBOX frames

for example, an interlaced mpeg2 video can be decoded by avcodec,
uploaded into a CVPixelBuffer, deinterlaced by Metal, and then
encoded to h264 by VideoToolbox as follows:

    ffmpeg \
           -init_hw_device videotoolbox \
           -i interlaced.ts \
           -vf hwupload,yadif_videotoolbox \
           -c:v h264_videotoolbox \
           -b:v 2000k \
           -c:a copy \
           -y progressive.ts

(note that uploading AVFrame into CVPixelBuffer via hwupload
 requires 504c60660d3194758823ddd45ceddb86e35d806f)

this work is sponsored by Fancy Bits LLC

Reviewed-by: Ridley Combs <rcombs@rcombs.me>
Signed-off-by: Aman Karmani <aman@tmm1.net>
---
 configure                                     |   1 +
 libavfilter/Makefile                          |   4 +
 libavfilter/allfilters.c                      |   1 +
 libavfilter/metal/vf_yadif_videotoolbox.metal | 269 ++++++++++++
 libavfilter/vf_yadif_videotoolbox.m           | 406 ++++++++++++++++++
 5 files changed, 681 insertions(+)
 create mode 100644 libavfilter/metal/vf_yadif_videotoolbox.metal
 create mode 100644 libavfilter/vf_yadif_videotoolbox.m

diff --git a/configure b/configure
index 32a39f5f5b..d8b07c8e00 100755
--- a/configure
+++ b/configure
@@ -3748,6 +3748,7 @@ vpp_qsv_filter_select="qsvvpp"
 xfade_opencl_filter_deps="opencl"
 yadif_cuda_filter_deps="ffnvcodec"
 yadif_cuda_filter_deps_any="cuda_nvcc cuda_llvm"
+yadif_videotoolbox_filter_deps="metal corevideo videotoolbox"
 
 # examples
 avio_list_dir_deps="avformat avutil"
diff --git a/libavfilter/Makefile b/libavfilter/Makefile
index 2fe495df28..9a061ba3c8 100644
--- a/libavfilter/Makefile
+++ b/libavfilter/Makefile
@@ -519,6 +519,10 @@ OBJS-$(CONFIG_XSTACK_FILTER)                 += vf_stack.o framesync.o
 OBJS-$(CONFIG_YADIF_FILTER)                  += vf_yadif.o yadif_common.o
 OBJS-$(CONFIG_YADIF_CUDA_FILTER)             += vf_yadif_cuda.o vf_yadif_cuda.ptx.o \
                                                 yadif_common.o cuda/load_helper.o
+OBJS-$(CONFIG_YADIF_VIDEOTOOLBOX_FILTER)     += vf_yadif_videotoolbox.o \
+                                                metal/vf_yadif_videotoolbox.metallib.o \
+                                                metal/utils.o \
+                                                yadif_common.o
 OBJS-$(CONFIG_YAEPBLUR_FILTER)               += vf_yaepblur.o
 OBJS-$(CONFIG_ZMQ_FILTER)                    += f_zmq.o
 OBJS-$(CONFIG_ZOOMPAN_FILTER)                += vf_zoompan.o
diff --git a/libavfilter/allfilters.c b/libavfilter/allfilters.c
index ec57a2c49c..26f1c73505 100644
--- a/libavfilter/allfilters.c
+++ b/libavfilter/allfilters.c
@@ -496,6 +496,7 @@ extern const AVFilter ff_vf_xmedian;
 extern const AVFilter ff_vf_xstack;
 extern const AVFilter ff_vf_yadif;
 extern const AVFilter ff_vf_yadif_cuda;
+extern const AVFilter ff_vf_yadif_videotoolbox;
 extern const AVFilter ff_vf_yaepblur;
 extern const AVFilter ff_vf_zmq;
 extern const AVFilter ff_vf_zoompan;
diff --git a/libavfilter/metal/vf_yadif_videotoolbox.metal b/libavfilter/metal/vf_yadif_videotoolbox.metal
new file mode 100644
index 0000000000..50783f2ffe
--- /dev/null
+++ b/libavfilter/metal/vf_yadif_videotoolbox.metal
@@ -0,0 +1,269 @@
+/*
+ * Copyright (C) 2018 Philip Langdale <philipl@overt.org>
+ *               2020 Aman Karmani <aman@tmm1.net>
+ *               2020 Stefan Dyulgerov <stefan.dyulgerov@gmail.com>
+ *
+ * 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <metal_stdlib>
+#include <metal_integer>
+#include <metal_texture>
+
+using namespace metal;
+
+/*
+ * Parameters
+ */
+
+struct deintParams {
+    uint channels;
+    uint parity;
+    uint tff;
+    bool is_second_field;
+    bool skip_spatial_check;
+    int field_mode;
+};
+
+/*
+ * Texture access helpers
+ */
+
+#define accesstype access::sample
+const sampler s(coord::pixel);
+
+template <typename T>
+T tex2D(texture2d<float, access::sample> tex, uint x, uint y)
+{
+    return tex.sample(s, float2(x, y)).x;
+}
+
+template <>
+float2 tex2D<float2>(texture2d<float, access::sample> tex, uint x, uint y)
+{
+    return tex.sample(s, float2(x, y)).xy;
+}
+
+template <typename T>
+T tex2D(texture2d<float, access::read> tex, uint x, uint y)
+{
+    return tex.read(uint2(x, y)).x;
+}
+
+template <>
+float2 tex2D<float2>(texture2d<float, access::read> tex, uint x, uint y)
+{
+    return tex.read(uint2(x, y)).xy;
+}
+
+/*
+ * YADIF helpers
+ */
+
+template<typename T>
+T spatial_predictor(T a, T b, T c, T d, T e, T f, T g,
+                    T h, T i, T j, T k, T l, T m, T n)
+{
+    T spatial_pred = (d + k)/2;
+    T spatial_score = abs(c - j) + abs(d - k) + abs(e - l);
+
+    T score = abs(b - k) + abs(c - l) + abs(d - m);
+    if (score < spatial_score) {
+        spatial_pred = (c + l)/2;
+        spatial_score = score;
+        score = abs(a - l) + abs(b - m) + abs(c - n);
+        if (score < spatial_score) {
+            spatial_pred = (b + m)/2;
+            spatial_score = score;
+        }
+    }
+    score = abs(d - i) + abs(e - j) + abs(f - k);
+    if (score < spatial_score) {
+        spatial_pred = (e + j)/2;
+        spatial_score = score;
+        score = abs(e - h) + abs(f - i) + abs(g - j);
+        if (score < spatial_score) {
+            spatial_pred = (f + i)/2;
+            spatial_score = score;
+        }
+    }
+    return spatial_pred;
+}
+
+template<typename T>
+T temporal_predictor(T A, T B, T C, T D, T E, T F,
+                     T G, T H, T I, T J, T K, T L,
+                     T spatial_pred, bool skip_check)
+{
+    T p0 = (C + H) / 2;
+    T p1 = F;
+    T p2 = (D + I) / 2;
+    T p3 = G;
+    T p4 = (E + J) / 2;
+
+    T tdiff0 = abs(D - I);
+    T tdiff1 = (abs(A - F) + abs(B - G)) / 2;
+    T tdiff2 = (abs(K - F) + abs(G - L)) / 2;
+
+    T diff = max3(tdiff0, tdiff1, tdiff2);
+
+    if (!skip_check) {
+        T maxi = max3(p2 - p3, p2 - p1, min(p0 - p1, p4 - p3));
+        T mini = min3(p2 - p3, p2 - p1, max(p0 - p1, p4 - p3));
+        diff = max3(diff, mini, -maxi);
+    }
+
+    return clamp(spatial_pred, p2 - diff, p2 + diff);
+}
+
+#define T float2
+template <>
+T spatial_predictor<T>(T a, T b, T c, T d, T e, T f, T g,
+                       T h, T i, T j, T k, T l, T m, T n)
+{
+    return T(
+        spatial_predictor(a.x, b.x, c.x, d.x, e.x, f.x, g.x,
+                          h.x, i.x, j.x, k.x, l.x, m.x, n.x),
+        spatial_predictor(a.y, b.y, c.y, d.y, e.y, f.y, g.y,
+                          h.y, i.y, j.y, k.y, l.y, m.y, n.y)
+    );
+}
+
+template <>
+T temporal_predictor<T>(T A, T B, T C, T D, T E, T F,
+                        T G, T H, T I, T J, T K, T L,
+                        T spatial_pred, bool skip_check)
+{
+    return T(
+        temporal_predictor(A.x, B.x, C.x, D.x, E.x, F.x,
+                           G.x, H.x, I.x, J.x, K.x, L.x,
+                           spatial_pred.x, skip_check),
+        temporal_predictor(A.y, B.y, C.y, D.y, E.y, F.y,
+                           G.y, H.y, I.y, J.y, K.y, L.y,
+                           spatial_pred.y, skip_check)
+    );
+}
+#undef T
+
+/*
+ * YADIF compute
+ */
+
+template <typename T>
+T yadif_compute_spatial(
+    texture2d<float, accesstype> cur,
+    uint2 pos)
+{
+    // Calculate spatial prediction
+    T a = tex2D<T>(cur, pos.x - 3, pos.y - 1);
+    T b = tex2D<T>(cur, pos.x - 2, pos.y - 1);
+    T c = tex2D<T>(cur, pos.x - 1, pos.y - 1);
+    T d = tex2D<T>(cur, pos.x - 0, pos.y - 1);
+    T e = tex2D<T>(cur, pos.x + 1, pos.y - 1);
+    T f = tex2D<T>(cur, pos.x + 2, pos.y - 1);
+    T g = tex2D<T>(cur, pos.x + 3, pos.y - 1);
+
+    T h = tex2D<T>(cur, pos.x - 3, pos.y + 1);
+    T i = tex2D<T>(cur, pos.x - 2, pos.y + 1);
+    T j = tex2D<T>(cur, pos.x - 1, pos.y + 1);
+    T k = tex2D<T>(cur, pos.x - 0, pos.y + 1);
+    T l = tex2D<T>(cur, pos.x + 1, pos.y + 1);
+    T m = tex2D<T>(cur, pos.x + 2, pos.y + 1);
+    T n = tex2D<T>(cur, pos.x + 3, pos.y + 1);
+
+    return spatial_predictor(a, b, c, d, e, f, g,
+                             h, i, j, k, l, m, n);
+}
+
+template <typename T>
+T yadif_compute_temporal(
+    texture2d<float, accesstype> cur,
+    texture2d<float, accesstype> prev2,
+    texture2d<float, accesstype> prev1,
+    texture2d<float, accesstype> next1,
+    texture2d<float, accesstype> next2,
+    T spatial_pred,
+    bool skip_spatial_check,
+    uint2 pos)
+{
+    // Calculate temporal prediction
+    T A = tex2D<T>(prev2, pos.x, pos.y - 1);
+    T B = tex2D<T>(prev2, pos.x, pos.y + 1);
+    T C = tex2D<T>(prev1, pos.x, pos.y - 2);
+    T D = tex2D<T>(prev1, pos.x, pos.y + 0);
+    T E = tex2D<T>(prev1, pos.x, pos.y + 2);
+    T F = tex2D<T>(cur,   pos.x, pos.y - 1);
+    T G = tex2D<T>(cur,   pos.x, pos.y + 1);
+    T H = tex2D<T>(next1, pos.x, pos.y - 2);
+    T I = tex2D<T>(next1, pos.x, pos.y + 0);
+    T J = tex2D<T>(next1, pos.x, pos.y + 2);
+    T K = tex2D<T>(next2, pos.x, pos.y - 1);
+    T L = tex2D<T>(next2, pos.x, pos.y + 1);
+
+    return temporal_predictor(A, B, C, D, E, F, G, H, I, J, K, L,
+                              spatial_pred, skip_spatial_check);
+}
+
+template <typename T>
+T yadif(
+    texture2d<float, access::write> dst,
+    texture2d<float, accesstype> prev,
+    texture2d<float, accesstype> cur,
+    texture2d<float, accesstype> next,
+    constant deintParams& params,
+    uint2 pos)
+{
+    T spatial_pred = yadif_compute_spatial<T>(cur, pos);
+
+    if (params.is_second_field) {
+        return yadif_compute_temporal(cur, prev, cur, next, next, spatial_pred, params.skip_spatial_check, pos);
+    } else {
+        return yadif_compute_temporal(cur, prev, prev, cur, next, spatial_pred, params.skip_spatial_check, pos);
+    }
+}
+
+/*
+ * Kernel dispatch
+ */
+
+kernel void deint(
+    texture2d<float, access::write> dst [[texture(0)]],
+    texture2d<float, accesstype> prev [[texture(1)]],
+    texture2d<float, accesstype> cur  [[texture(2)]],
+    texture2d<float, accesstype> next [[texture(3)]],
+    constant deintParams& params [[buffer(4)]],
+    uint2 pos [[thread_position_in_grid]])
+{
+    if ((pos.x >= dst.get_width()) ||
+        (pos.y >= dst.get_height())) {
+        return;
+    }
+
+    // Don't modify the primary field
+    if (pos.y % 2 == params.parity) {
+        float4 in = cur.read(pos);
+        dst.write(in, pos);
+        return;
+    }
+
+    float2 pred;
+    if (params.channels == 1)
+        pred = float2(yadif<float>(dst, prev, cur, next, params, pos));
+    else
+        pred = yadif<float2>(dst, prev, cur, next, params, pos);
+    dst.write(pred.xyyy, pos);
+}
diff --git a/libavfilter/vf_yadif_videotoolbox.m b/libavfilter/vf_yadif_videotoolbox.m
new file mode 100644
index 0000000000..af83a73e89
--- /dev/null
+++ b/libavfilter/vf_yadif_videotoolbox.m
@@ -0,0 +1,406 @@
+/*
+ * Copyright (C) 2018 Philip Langdale <philipl@overt.org>
+ *               2020 Aman Karmani <aman@tmm1.net>
+ *
+ * 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "internal.h"
+#include "yadif.h"
+#include <libavutil/avassert.h>
+#include <libavutil/hwcontext.h>
+#include <libavutil/objc.h>
+#include <libavfilter/metal/utils.h>
+
+extern char ff_vf_yadif_videotoolbox_metallib_data[];
+extern unsigned int ff_vf_yadif_videotoolbox_metallib_len;
+
+typedef struct YADIFVTContext {
+    YADIFContext yadif;
+
+    AVBufferRef       *device_ref;
+    AVBufferRef       *input_frames_ref;
+    AVHWFramesContext *input_frames;
+
+    id<MTLDevice> mtlDevice;
+    id<MTLLibrary> mtlLibrary;
+    id<MTLCommandQueue> mtlQueue;
+    id<MTLComputePipelineState> mtlPipeline;
+    id<MTLFunction> mtlFunction;
+    id<MTLBuffer> mtlParamsBuffer;
+
+    CVMetalTextureCacheRef textureCache;
+} YADIFVTContext;
+
+struct mtlYadifParams {
+    uint channels;
+    uint parity;
+    uint tff;
+    bool is_second_field;
+    bool skip_spatial_check;
+    int field_mode;
+};
+
+static void call_kernel(AVFilterContext *ctx,
+                        id<MTLTexture> dst,
+                        id<MTLTexture> prev,
+                        id<MTLTexture> cur,
+                        id<MTLTexture> next,
+                        int channels,
+                        int parity,
+                        int tff)
+{
+    YADIFVTContext *s = ctx->priv;
+    id<MTLCommandBuffer> buffer = s->mtlQueue.commandBuffer;
+    id<MTLComputeCommandEncoder> encoder = buffer.computeCommandEncoder;
+    struct mtlYadifParams *params = (struct mtlYadifParams *)s->mtlParamsBuffer.contents;
+    *params = (struct mtlYadifParams){
+        .channels = channels,
+        .parity = parity,
+        .tff = tff,
+        .is_second_field = !(parity ^ tff),
+        .skip_spatial_check = s->yadif.mode&2,
+        .field_mode = s->yadif.current_field
+    };
+
+    [encoder setTexture:dst  atIndex:0];
+    [encoder setTexture:prev atIndex:1];
+    [encoder setTexture:cur  atIndex:2];
+    [encoder setTexture:next atIndex:3];
+    [encoder setBuffer:s->mtlParamsBuffer offset:0 atIndex:4];
+    ff_metal_compute_encoder_dispatch(s->mtlDevice, s->mtlPipeline, encoder, dst.width, dst.height);
+    [encoder endEncoding];
+
+    [buffer commit];
+    [buffer waitUntilCompleted];
+
+    ff_objc_release(&encoder);
+    ff_objc_release(&buffer);
+}
+
+static void filter(AVFilterContext *ctx, AVFrame *dst,
+                   int parity, int tff)
+{
+    YADIFVTContext *s = ctx->priv;
+    YADIFContext *y = &s->yadif;
+    int i;
+
+    for (i = 0; i < y->csp->nb_components; i++) {
+        int pixel_size, channels;
+        const AVComponentDescriptor *comp = &y->csp->comp[i];
+        CVMetalTextureRef prev, cur, next, dest;
+        id<MTLTexture> tex_prev, tex_cur, tex_next, tex_dest;
+        MTLPixelFormat format;
+
+        if (comp->plane < i) {
+            // We process planes as a whole, so don't reprocess
+            // them for additional components
+            continue;
+        }
+
+        pixel_size = (comp->depth + comp->shift) / 8;
+        channels = comp->step / pixel_size;
+        if (pixel_size > 2 || channels > 2) {
+            av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format: %s\n", y->csp->name);
+            goto exit;
+        }
+        switch (pixel_size) {
+        case 1:
+            format = channels == 1 ? MTLPixelFormatR8Unorm : MTLPixelFormatRG8Unorm;
+            break;
+        case 2:
+            format = channels == 1 ? MTLPixelFormatR16Unorm : MTLPixelFormatRG16Unorm;
+            break;
+        default:
+            av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format: %s\n", y->csp->name);
+            goto exit;
+        }
+        av_log(ctx, AV_LOG_TRACE,
+               "Deinterlacing plane %d: pixel_size: %d channels: %d\n",
+               comp->plane, pixel_size, channels);
+
+        prev = ff_metal_texture_from_pixbuf(ctx, s->textureCache, (CVPixelBufferRef)y->prev->data[3], i, format);
+        cur  = ff_metal_texture_from_pixbuf(ctx, s->textureCache, (CVPixelBufferRef)y->cur->data[3], i, format);
+        next = ff_metal_texture_from_pixbuf(ctx, s->textureCache, (CVPixelBufferRef)y->next->data[3], i, format);
+        dest = ff_metal_texture_from_pixbuf(ctx, s->textureCache, (CVPixelBufferRef)dst->data[3], i, format);
+
+        tex_prev = CVMetalTextureGetTexture(prev);
+        tex_cur  = CVMetalTextureGetTexture(cur);
+        tex_next = CVMetalTextureGetTexture(next);
+        tex_dest = CVMetalTextureGetTexture(dest);
+
+        call_kernel(ctx, tex_dest, tex_prev, tex_cur, tex_next,
+                         channels, parity, tff);
+
+        CFRelease(prev);
+        CFRelease(cur);
+        CFRelease(next);
+        CFRelease(dest);
+    }
+
+    CVBufferPropagateAttachments((CVPixelBufferRef)y->cur->data[3], (CVPixelBufferRef)dst->data[3]);
+
+    if (y->current_field == YADIF_FIELD_END) {
+        y->current_field = YADIF_FIELD_NORMAL;
+    }
+
+exit:
+    return;
+}
+
+static av_cold void yadif_videotoolbox_uninit(AVFilterContext *ctx)
+{
+    YADIFVTContext *s = ctx->priv;
+    YADIFContext *y = &s->yadif;
+
+    av_frame_free(&y->prev);
+    av_frame_free(&y->cur);
+    av_frame_free(&y->next);
+
+    av_buffer_unref(&s->device_ref);
+    av_buffer_unref(&s->input_frames_ref);
+    s->input_frames = NULL;
+
+    ff_objc_release(&s->mtlParamsBuffer);
+    ff_objc_release(&s->mtlFunction);
+    ff_objc_release(&s->mtlPipeline);
+    ff_objc_release(&s->mtlQueue);
+    ff_objc_release(&s->mtlLibrary);
+    ff_objc_release(&s->mtlDevice);
+
+    if (s->textureCache) {
+        CFRelease(s->textureCache);
+        s->textureCache = NULL;
+    }
+}
+
+static av_cold int yadif_videotoolbox_init(AVFilterContext *ctx)
+{
+    YADIFVTContext *s = ctx->priv;
+    NSError *err = nil;
+    CVReturn ret;
+
+    s->mtlDevice = MTLCreateSystemDefaultDevice();
+    if (!s->mtlDevice) {
+        av_log(ctx, AV_LOG_ERROR, "Unable to find Metal device\n");
+        goto fail;
+    }
+
+    av_log(ctx, AV_LOG_INFO, "Using Metal device: %s\n", s->mtlDevice.name.UTF8String);
+
+    dispatch_data_t libData = dispatch_data_create(
+        ff_vf_yadif_videotoolbox_metallib_data,
+        ff_vf_yadif_videotoolbox_metallib_len,
+        nil,
+        nil);
+    s->mtlLibrary = [s->mtlDevice newLibraryWithData:libData error:&err];
+    dispatch_release(libData);
+    libData = nil;
+    if (err) {
+        av_log(ctx, AV_LOG_ERROR, "Failed to load Metal library: %s\n", err.description.UTF8String);
+        goto fail;
+    }
+
+    s->mtlFunction = [s->mtlLibrary newFunctionWithName:@"deint"];
+    if (!s->mtlFunction) {
+        av_log(ctx, AV_LOG_ERROR, "Failed to create Metal function!\n");
+        goto fail;
+    }
+
+    s->mtlQueue = s->mtlDevice.newCommandQueue;
+    if (!s->mtlQueue) {
+        av_log(ctx, AV_LOG_ERROR, "Failed to create Metal command queue!\n");
+        goto fail;
+    }
+
+    s->mtlPipeline = [s->mtlDevice
+        newComputePipelineStateWithFunction:s->mtlFunction
+        error:&err];
+    if (err) {
+        av_log(ctx, AV_LOG_ERROR, "Failed to create Metal compute pipeline: %s\n", err.description.UTF8String);
+        goto fail;
+    }
+
+    s->mtlParamsBuffer = [s->mtlDevice
+        newBufferWithLength:sizeof(struct mtlYadifParams)
+        options:MTLResourceStorageModeShared];
+    if (!s->mtlParamsBuffer) {
+        av_log(ctx, AV_LOG_ERROR, "Failed to create Metal buffer for parameters\n");
+        goto fail;
+    }
+
+    ret = CVMetalTextureCacheCreate(
+        NULL,
+        NULL,
+        s->mtlDevice,
+        NULL,
+        &s->textureCache
+    );
+    if (ret != kCVReturnSuccess) {
+        av_log(ctx, AV_LOG_ERROR, "Failed to create CVMetalTextureCache: %d\n", ret);
+        goto fail;
+    }
+
+    return 0;
+fail:
+    yadif_videotoolbox_uninit(ctx);
+    return AVERROR_EXTERNAL;
+}
+
+static int config_input(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx = inlink->dst;
+    YADIFVTContext *s = ctx->priv;
+
+    if (!inlink->hw_frames_ctx) {
+        av_log(ctx, AV_LOG_ERROR, "A hardware frames reference is "
+               "required to associate the processing device.\n");
+        return AVERROR(EINVAL);
+    }
+
+    s->input_frames_ref = av_buffer_ref(inlink->hw_frames_ctx);
+    if (!s->input_frames_ref) {
+        av_log(ctx, AV_LOG_ERROR, "A input frames reference create "
+               "failed.\n");
+        return AVERROR(ENOMEM);
+    }
+    s->input_frames = (AVHWFramesContext*)s->input_frames_ref->data;
+
+    return 0;
+}
+
+static int config_output(AVFilterLink *link)
+{
+    AVHWFramesContext *output_frames;
+    AVFilterContext *ctx = link->src;
+    YADIFVTContext *s = ctx->priv;
+    YADIFContext *y = &s->yadif;
+    int ret = 0;
+
+    av_assert0(s->input_frames);
+    s->device_ref = av_buffer_ref(s->input_frames->device_ref);
+    if (!s->device_ref) {
+        av_log(ctx, AV_LOG_ERROR, "A device reference create "
+               "failed.\n");
+        return AVERROR(ENOMEM);
+    }
+
+    link->hw_frames_ctx = av_hwframe_ctx_alloc(s->device_ref);
+    if (!link->hw_frames_ctx) {
+        av_log(ctx, AV_LOG_ERROR, "Failed to create HW frame context "
+               "for output.\n");
+        ret = AVERROR(ENOMEM);
+        goto exit;
+    }
+
+    output_frames = (AVHWFramesContext*)link->hw_frames_ctx->data;
+
+    output_frames->format    = AV_PIX_FMT_VIDEOTOOLBOX;
+    output_frames->sw_format = s->input_frames->sw_format;
+    output_frames->width     = ctx->inputs[0]->w;
+    output_frames->height    = ctx->inputs[0]->h;
+
+    ret = ff_filter_init_hw_frames(ctx, link, 10);
+    if (ret < 0)
+        goto exit;
+
+    ret = av_hwframe_ctx_init(link->hw_frames_ctx);
+    if (ret < 0) {
+        av_log(ctx, AV_LOG_ERROR, "Failed to initialise VideoToolbox frame "
+               "context for output: %d\n", ret);
+        goto exit;
+    }
+
+    link->time_base.num = ctx->inputs[0]->time_base.num;
+    link->time_base.den = ctx->inputs[0]->time_base.den * 2;
+    link->w             = ctx->inputs[0]->w;
+    link->h             = ctx->inputs[0]->h;
+
+    if(y->mode & 1)
+        link->frame_rate = av_mul_q(ctx->inputs[0]->frame_rate,
+                                    (AVRational){2, 1});
+
+    if (link->w < 3 || link->h < 3) {
+        av_log(ctx, AV_LOG_ERROR, "Video of less than 3 columns or lines is not supported\n");
+        ret = AVERROR(EINVAL);
+        goto exit;
+    }
+
+    y->csp = av_pix_fmt_desc_get(output_frames->sw_format);
+    y->filter = filter;
+
+exit:
+    return ret;
+}
+
+#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
+#define CONST(name, help, val, unit) { name, help, 0, AV_OPT_TYPE_CONST, {.i64=val}, INT_MIN, INT_MAX, FLAGS, unit }
+
+static const AVOption yadif_videotoolbox_options[] = {
+    #define OFFSET(x) offsetof(YADIFContext, x)
+    { "mode",   "specify the interlacing mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=YADIF_MODE_SEND_FRAME}, 0, 3, FLAGS, "mode"},
+    CONST("send_frame",           "send one frame for each frame",                                     YADIF_MODE_SEND_FRAME,           "mode"),
+    CONST("send_field",           "send one frame for each field",                                     YADIF_MODE_SEND_FIELD,           "mode"),
+    CONST("send_frame_nospatial", "send one frame for each frame, but skip spatial interlacing check", YADIF_MODE_SEND_FRAME_NOSPATIAL, "mode"),
+    CONST("send_field_nospatial", "send one frame for each field, but skip spatial interlacing check", YADIF_MODE_SEND_FIELD_NOSPATIAL, "mode"),
+
+    { "parity", "specify the assumed picture field parity", OFFSET(parity), AV_OPT_TYPE_INT, {.i64=YADIF_PARITY_AUTO}, -1, 1, FLAGS, "parity" },
+    CONST("tff",  "assume top field first",    YADIF_PARITY_TFF,  "parity"),
+    CONST("bff",  "assume bottom field first", YADIF_PARITY_BFF,  "parity"),
+    CONST("auto", "auto detect parity",        YADIF_PARITY_AUTO, "parity"),
+
+    { "deint", "specify which frames to deinterlace", OFFSET(deint), AV_OPT_TYPE_INT, {.i64=YADIF_DEINT_ALL}, 0, 1, FLAGS, "deint" },
+    CONST("all",        "deinterlace all frames",                       YADIF_DEINT_ALL,        "deint"),
+    CONST("interlaced", "only deinterlace frames marked as interlaced", YADIF_DEINT_INTERLACED, "deint"),
+    #undef OFFSET
+
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(yadif_videotoolbox);
+
+static const AVFilterPad yadif_videotoolbox_inputs[] = {
+    {
+        .name          = "default",
+        .type          = AVMEDIA_TYPE_VIDEO,
+        .filter_frame  = ff_yadif_filter_frame,
+        .config_props  = config_input,
+    },
+};
+
+static const AVFilterPad yadif_videotoolbox_outputs[] = {
+    {
+        .name          = "default",
+        .type          = AVMEDIA_TYPE_VIDEO,
+        .request_frame = ff_yadif_request_frame,
+        .config_props  = config_output,
+    },
+};
+
+AVFilter ff_vf_yadif_videotoolbox = {
+    .name           = "yadif_videotoolbox",
+    .description    = NULL_IF_CONFIG_SMALL("YADIF for VideoToolbox frames using Metal compute"),
+    .priv_size      = sizeof(YADIFVTContext),
+    .priv_class     = &yadif_videotoolbox_class,
+    .init           = yadif_videotoolbox_init,
+    .uninit         = yadif_videotoolbox_uninit,
+    FILTER_SINGLE_PIXFMT(AV_PIX_FMT_VIDEOTOOLBOX),
+    FILTER_INPUTS(yadif_videotoolbox_inputs),
+    FILTER_OUTPUTS(yadif_videotoolbox_outputs),
+    .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
+    .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
+};
-- 
2.33.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

Re: [FFmpeg-devel] [PATCH v4 5/5] avfilter: add vf_yadif_videotoolbox

[Philip Langdale]

On Fri, 17 Dec 2021 12:04:18 -0800
Aman Karmani <ffmpeg@tmm1.net> wrote:

> From: Aman Karmani <aman@tmm1.net>
> 
> deinterlaces CVPixelBuffers, i.e. AV_PIX_FMT_VIDEOTOOLBOX frames
> 
> for example, an interlaced mpeg2 video can be decoded by avcodec,
> uploaded into a CVPixelBuffer, deinterlaced by Metal, and then
> encoded to h264 by VideoToolbox as follows:
> 
>     ffmpeg \
>            -init_hw_device videotoolbox \
>            -i interlaced.ts \
>            -vf hwupload,yadif_videotoolbox \
>            -c:v h264_videotoolbox \
>            -b:v 2000k \
>            -c:a copy \
>            -y progressive.ts
> 
> (note that uploading AVFrame into CVPixelBuffer via hwupload
>  requires 504c60660d3194758823ddd45ceddb86e35d806f)
> 
> this work is sponsored by Fancy Bits LLC
> 
> Reviewed-by: Ridley Combs <rcombs@rcombs.me>
> Signed-off-by: Aman Karmani <aman@tmm1.net>
> ---
>  configure                                     |   1 +
>  libavfilter/Makefile                          |   4 +
>  libavfilter/allfilters.c                      |   1 +
>  libavfilter/metal/vf_yadif_videotoolbox.metal | 269 ++++++++++++
>  libavfilter/vf_yadif_videotoolbox.m           | 406
> ++++++++++++++++++ 5 files changed, 681 insertions(+)
>  create mode 100644 libavfilter/metal/vf_yadif_videotoolbox.metal
>  create mode 100644 libavfilter/vf_yadif_videotoolbox.m
> 
> diff --git a/configure b/configure
> index 32a39f5f5b..d8b07c8e00 100755
> --- a/configure
> +++ b/configure
> @@ -3748,6 +3748,7 @@ vpp_qsv_filter_select="qsvvpp"
>  xfade_opencl_filter_deps="opencl"
>  yadif_cuda_filter_deps="ffnvcodec"
>  yadif_cuda_filter_deps_any="cuda_nvcc cuda_llvm"
> +yadif_videotoolbox_filter_deps="metal corevideo videotoolbox"
>  
>  # examples
>  avio_list_dir_deps="avformat avutil"
> diff --git a/libavfilter/Makefile b/libavfilter/Makefile
> index 2fe495df28..9a061ba3c8 100644
> --- a/libavfilter/Makefile
> +++ b/libavfilter/Makefile
> @@ -519,6 +519,10 @@ OBJS-$(CONFIG_XSTACK_FILTER)                 +=
> vf_stack.o framesync.o OBJS-$(CONFIG_YADIF_FILTER)
> += vf_yadif.o yadif_common.o OBJS-$(CONFIG_YADIF_CUDA_FILTER)
>     += vf_yadif_cuda.o vf_yadif_cuda.ptx.o \ yadif_common.o
> cuda/load_helper.o +OBJS-$(CONFIG_YADIF_VIDEOTOOLBOX_FILTER)     +=
> vf_yadif_videotoolbox.o \
> +
> metal/vf_yadif_videotoolbox.metallib.o \
> +                                                metal/utils.o \
> +                                                yadif_common.o
>  OBJS-$(CONFIG_YAEPBLUR_FILTER)               += vf_yaepblur.o
>  OBJS-$(CONFIG_ZMQ_FILTER)                    += f_zmq.o
>  OBJS-$(CONFIG_ZOOMPAN_FILTER)                += vf_zoompan.o
> diff --git a/libavfilter/allfilters.c b/libavfilter/allfilters.c
> index ec57a2c49c..26f1c73505 100644
> --- a/libavfilter/allfilters.c
> +++ b/libavfilter/allfilters.c
> @@ -496,6 +496,7 @@ extern const AVFilter ff_vf_xmedian;
>  extern const AVFilter ff_vf_xstack;
>  extern const AVFilter ff_vf_yadif;
>  extern const AVFilter ff_vf_yadif_cuda;
> +extern const AVFilter ff_vf_yadif_videotoolbox;
>  extern const AVFilter ff_vf_yaepblur;
>  extern const AVFilter ff_vf_zmq;
>  extern const AVFilter ff_vf_zoompan;
> diff --git a/libavfilter/metal/vf_yadif_videotoolbox.metal
> b/libavfilter/metal/vf_yadif_videotoolbox.metal new file mode 100644
> index 0000000000..50783f2ffe
> --- /dev/null
> +++ b/libavfilter/metal/vf_yadif_videotoolbox.metal
> @@ -0,0 +1,269 @@
> +/*
> + * Copyright (C) 2018 Philip Langdale <philipl@overt.org>
> + *               2020 Aman Karmani <aman@tmm1.net>
> + *               2020 Stefan Dyulgerov <stefan.dyulgerov@gmail.com>
> + *
> + * 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 FFmpeg; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
> 02110-1301 USA
> + */
> +
> +#include <metal_stdlib>
> +#include <metal_integer>
> +#include <metal_texture>
> +
> +using namespace metal;
> +
> +/*
> + * Parameters
> + */
> +
> +struct deintParams {
> +    uint channels;
> +    uint parity;
> +    uint tff;
> +    bool is_second_field;
> +    bool skip_spatial_check;
> +    int field_mode;
> +};
> +
> +/*
> + * Texture access helpers
> + */
> +
> +#define accesstype access::sample
> +const sampler s(coord::pixel);
> +
> +template <typename T>
> +T tex2D(texture2d<float, access::sample> tex, uint x, uint y)
> +{
> +    return tex.sample(s, float2(x, y)).x;
> +}
> +
> +template <>
> +float2 tex2D<float2>(texture2d<float, access::sample> tex, uint x,
> uint y) +{
> +    return tex.sample(s, float2(x, y)).xy;
> +}
> +
> +template <typename T>
> +T tex2D(texture2d<float, access::read> tex, uint x, uint y)
> +{
> +    return tex.read(uint2(x, y)).x;
> +}
> +
> +template <>
> +float2 tex2D<float2>(texture2d<float, access::read> tex, uint x,
> uint y) +{
> +    return tex.read(uint2(x, y)).xy;
> +}
> +
> +/*
> + * YADIF helpers
> + */
> +
> +template<typename T>
> +T spatial_predictor(T a, T b, T c, T d, T e, T f, T g,
> +                    T h, T i, T j, T k, T l, T m, T n)
> +{
> +    T spatial_pred = (d + k)/2;
> +    T spatial_score = abs(c - j) + abs(d - k) + abs(e - l);
> +
> +    T score = abs(b - k) + abs(c - l) + abs(d - m);
> +    if (score < spatial_score) {
> +        spatial_pred = (c + l)/2;
> +        spatial_score = score;
> +        score = abs(a - l) + abs(b - m) + abs(c - n);
> +        if (score < spatial_score) {
> +            spatial_pred = (b + m)/2;
> +            spatial_score = score;
> +        }
> +    }
> +    score = abs(d - i) + abs(e - j) + abs(f - k);
> +    if (score < spatial_score) {
> +        spatial_pred = (e + j)/2;
> +        spatial_score = score;
> +        score = abs(e - h) + abs(f - i) + abs(g - j);
> +        if (score < spatial_score) {
> +            spatial_pred = (f + i)/2;
> +            spatial_score = score;
> +        }
> +    }
> +    return spatial_pred;
> +}
> +
> +template<typename T>
> +T temporal_predictor(T A, T B, T C, T D, T E, T F,
> +                     T G, T H, T I, T J, T K, T L,
> +                     T spatial_pred, bool skip_check)
> +{
> +    T p0 = (C + H) / 2;
> +    T p1 = F;
> +    T p2 = (D + I) / 2;
> +    T p3 = G;
> +    T p4 = (E + J) / 2;
> +
> +    T tdiff0 = abs(D - I);
> +    T tdiff1 = (abs(A - F) + abs(B - G)) / 2;
> +    T tdiff2 = (abs(K - F) + abs(G - L)) / 2;
> +
> +    T diff = max3(tdiff0, tdiff1, tdiff2);
> +
> +    if (!skip_check) {
> +        T maxi = max3(p2 - p3, p2 - p1, min(p0 - p1, p4 - p3));
> +        T mini = min3(p2 - p3, p2 - p1, max(p0 - p1, p4 - p3));
> +        diff = max3(diff, mini, -maxi);
> +    }
> +
> +    return clamp(spatial_pred, p2 - diff, p2 + diff);
> +}
> +
> +#define T float2
> +template <>
> +T spatial_predictor<T>(T a, T b, T c, T d, T e, T f, T g,
> +                       T h, T i, T j, T k, T l, T m, T n)
> +{
> +    return T(
> +        spatial_predictor(a.x, b.x, c.x, d.x, e.x, f.x, g.x,
> +                          h.x, i.x, j.x, k.x, l.x, m.x, n.x),
> +        spatial_predictor(a.y, b.y, c.y, d.y, e.y, f.y, g.y,
> +                          h.y, i.y, j.y, k.y, l.y, m.y, n.y)
> +    );
> +}
> +
> +template <>
> +T temporal_predictor<T>(T A, T B, T C, T D, T E, T F,
> +                        T G, T H, T I, T J, T K, T L,
> +                        T spatial_pred, bool skip_check)
> +{
> +    return T(
> +        temporal_predictor(A.x, B.x, C.x, D.x, E.x, F.x,
> +                           G.x, H.x, I.x, J.x, K.x, L.x,
> +                           spatial_pred.x, skip_check),
> +        temporal_predictor(A.y, B.y, C.y, D.y, E.y, F.y,
> +                           G.y, H.y, I.y, J.y, K.y, L.y,
> +                           spatial_pred.y, skip_check)
> +    );
> +}
> +#undef T
> +
> +/*
> + * YADIF compute
> + */
> +
> +template <typename T>
> +T yadif_compute_spatial(
> +    texture2d<float, accesstype> cur,
> +    uint2 pos)
> +{
> +    // Calculate spatial prediction
> +    T a = tex2D<T>(cur, pos.x - 3, pos.y - 1);
> +    T b = tex2D<T>(cur, pos.x - 2, pos.y - 1);
> +    T c = tex2D<T>(cur, pos.x - 1, pos.y - 1);
> +    T d = tex2D<T>(cur, pos.x - 0, pos.y - 1);
> +    T e = tex2D<T>(cur, pos.x + 1, pos.y - 1);
> +    T f = tex2D<T>(cur, pos.x + 2, pos.y - 1);
> +    T g = tex2D<T>(cur, pos.x + 3, pos.y - 1);
> +
> +    T h = tex2D<T>(cur, pos.x - 3, pos.y + 1);
> +    T i = tex2D<T>(cur, pos.x - 2, pos.y + 1);
> +    T j = tex2D<T>(cur, pos.x - 1, pos.y + 1);
> +    T k = tex2D<T>(cur, pos.x - 0, pos.y + 1);
> +    T l = tex2D<T>(cur, pos.x + 1, pos.y + 1);
> +    T m = tex2D<T>(cur, pos.x + 2, pos.y + 1);
> +    T n = tex2D<T>(cur, pos.x + 3, pos.y + 1);
> +
> +    return spatial_predictor(a, b, c, d, e, f, g,
> +                             h, i, j, k, l, m, n);
> +}
> +
> +template <typename T>
> +T yadif_compute_temporal(
> +    texture2d<float, accesstype> cur,
> +    texture2d<float, accesstype> prev2,
> +    texture2d<float, accesstype> prev1,
> +    texture2d<float, accesstype> next1,
> +    texture2d<float, accesstype> next2,
> +    T spatial_pred,
> +    bool skip_spatial_check,
> +    uint2 pos)
> +{
> +    // Calculate temporal prediction
> +    T A = tex2D<T>(prev2, pos.x, pos.y - 1);
> +    T B = tex2D<T>(prev2, pos.x, pos.y + 1);
> +    T C = tex2D<T>(prev1, pos.x, pos.y - 2);
> +    T D = tex2D<T>(prev1, pos.x, pos.y + 0);
> +    T E = tex2D<T>(prev1, pos.x, pos.y + 2);
> +    T F = tex2D<T>(cur,   pos.x, pos.y - 1);
> +    T G = tex2D<T>(cur,   pos.x, pos.y + 1);
> +    T H = tex2D<T>(next1, pos.x, pos.y - 2);
> +    T I = tex2D<T>(next1, pos.x, pos.y + 0);
> +    T J = tex2D<T>(next1, pos.x, pos.y + 2);
> +    T K = tex2D<T>(next2, pos.x, pos.y - 1);
> +    T L = tex2D<T>(next2, pos.x, pos.y + 1);
> +
> +    return temporal_predictor(A, B, C, D, E, F, G, H, I, J, K, L,
> +                              spatial_pred, skip_spatial_check);
> +}
> +
> +template <typename T>
> +T yadif(
> +    texture2d<float, access::write> dst,
> +    texture2d<float, accesstype> prev,
> +    texture2d<float, accesstype> cur,
> +    texture2d<float, accesstype> next,
> +    constant deintParams& params,
> +    uint2 pos)
> +{
> +    T spatial_pred = yadif_compute_spatial<T>(cur, pos);
> +
> +    if (params.is_second_field) {
> +        return yadif_compute_temporal(cur, prev, cur, next, next,
> spatial_pred, params.skip_spatial_check, pos);
> +    } else {
> +        return yadif_compute_temporal(cur, prev, prev, cur, next,
> spatial_pred, params.skip_spatial_check, pos);
> +    }
> +}
> +
> +/*
> + * Kernel dispatch
> + */
> +
> +kernel void deint(
> +    texture2d<float, access::write> dst [[texture(0)]],
> +    texture2d<float, accesstype> prev [[texture(1)]],
> +    texture2d<float, accesstype> cur  [[texture(2)]],
> +    texture2d<float, accesstype> next [[texture(3)]],
> +    constant deintParams& params [[buffer(4)]],
> +    uint2 pos [[thread_position_in_grid]])
> +{
> +    if ((pos.x >= dst.get_width()) ||
> +        (pos.y >= dst.get_height())) {
> +        return;
> +    }
> +
> +    // Don't modify the primary field
> +    if (pos.y % 2 == params.parity) {
> +        float4 in = cur.read(pos);
> +        dst.write(in, pos);
> +        return;
> +    }
> +
> +    float2 pred;
> +    if (params.channels == 1)
> +        pred = float2(yadif<float>(dst, prev, cur, next, params,
> pos));
> +    else
> +        pred = yadif<float2>(dst, prev, cur, next, params, pos);
> +    dst.write(pred.xyyy, pos);
> +}
> diff --git a/libavfilter/vf_yadif_videotoolbox.m
> b/libavfilter/vf_yadif_videotoolbox.m new file mode 100644
> index 0000000000..af83a73e89
> --- /dev/null
> +++ b/libavfilter/vf_yadif_videotoolbox.m
> @@ -0,0 +1,406 @@
> +/*
> + * Copyright (C) 2018 Philip Langdale <philipl@overt.org>
> + *               2020 Aman Karmani <aman@tmm1.net>
> + *
> + * 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 FFmpeg; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
> 02110-1301 USA
> + */
> +
> +#include "internal.h"
> +#include "yadif.h"
> +#include <libavutil/avassert.h>
> +#include <libavutil/hwcontext.h>
> +#include <libavutil/objc.h>
> +#include <libavfilter/metal/utils.h>
> +
> +extern char ff_vf_yadif_videotoolbox_metallib_data[];
> +extern unsigned int ff_vf_yadif_videotoolbox_metallib_len;
> +
> +typedef struct YADIFVTContext {
> +    YADIFContext yadif;
> +
> +    AVBufferRef       *device_ref;
> +    AVBufferRef       *input_frames_ref;
> +    AVHWFramesContext *input_frames;
> +
> +    id<MTLDevice> mtlDevice;
> +    id<MTLLibrary> mtlLibrary;
> +    id<MTLCommandQueue> mtlQueue;
> +    id<MTLComputePipelineState> mtlPipeline;
> +    id<MTLFunction> mtlFunction;
> +    id<MTLBuffer> mtlParamsBuffer;
> +
> +    CVMetalTextureCacheRef textureCache;
> +} YADIFVTContext;
> +
> +struct mtlYadifParams {
> +    uint channels;
> +    uint parity;
> +    uint tff;
> +    bool is_second_field;
> +    bool skip_spatial_check;
> +    int field_mode;
> +};
> +
> +static void call_kernel(AVFilterContext *ctx,
> +                        id<MTLTexture> dst,
> +                        id<MTLTexture> prev,
> +                        id<MTLTexture> cur,
> +                        id<MTLTexture> next,
> +                        int channels,
> +                        int parity,
> +                        int tff)
> +{
> +    YADIFVTContext *s = ctx->priv;
> +    id<MTLCommandBuffer> buffer = s->mtlQueue.commandBuffer;
> +    id<MTLComputeCommandEncoder> encoder =
> buffer.computeCommandEncoder;
> +    struct mtlYadifParams *params = (struct mtlYadifParams
> *)s->mtlParamsBuffer.contents;
> +    *params = (struct mtlYadifParams){
> +        .channels = channels,
> +        .parity = parity,
> +        .tff = tff,
> +        .is_second_field = !(parity ^ tff),
> +        .skip_spatial_check = s->yadif.mode&2,
> +        .field_mode = s->yadif.current_field
> +    };
> +
> +    [encoder setTexture:dst  atIndex:0];
> +    [encoder setTexture:prev atIndex:1];
> +    [encoder setTexture:cur  atIndex:2];
> +    [encoder setTexture:next atIndex:3];
> +    [encoder setBuffer:s->mtlParamsBuffer offset:0 atIndex:4];
> +    ff_metal_compute_encoder_dispatch(s->mtlDevice, s->mtlPipeline,
> encoder, dst.width, dst.height);
> +    [encoder endEncoding];
> +
> +    [buffer commit];
> +    [buffer waitUntilCompleted];
> +
> +    ff_objc_release(&encoder);
> +    ff_objc_release(&buffer);
> +}
> +
> +static void filter(AVFilterContext *ctx, AVFrame *dst,
> +                   int parity, int tff)
> +{
> +    YADIFVTContext *s = ctx->priv;
> +    YADIFContext *y = &s->yadif;
> +    int i;
> +
> +    for (i = 0; i < y->csp->nb_components; i++) {
> +        int pixel_size, channels;
> +        const AVComponentDescriptor *comp = &y->csp->comp[i];
> +        CVMetalTextureRef prev, cur, next, dest;
> +        id<MTLTexture> tex_prev, tex_cur, tex_next, tex_dest;
> +        MTLPixelFormat format;
> +
> +        if (comp->plane < i) {
> +            // We process planes as a whole, so don't reprocess
> +            // them for additional components
> +            continue;
> +        }
> +
> +        pixel_size = (comp->depth + comp->shift) / 8;
> +        channels = comp->step / pixel_size;
> +        if (pixel_size > 2 || channels > 2) {
> +            av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format:
> %s\n", y->csp->name);
> +            goto exit;
> +        }
> +        switch (pixel_size) {
> +        case 1:
> +            format = channels == 1 ? MTLPixelFormatR8Unorm :
> MTLPixelFormatRG8Unorm;
> +            break;
> +        case 2:
> +            format = channels == 1 ? MTLPixelFormatR16Unorm :
> MTLPixelFormatRG16Unorm;
> +            break;
> +        default:
> +            av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format:
> %s\n", y->csp->name);
> +            goto exit;
> +        }
> +        av_log(ctx, AV_LOG_TRACE,
> +               "Deinterlacing plane %d: pixel_size: %d channels:
> %d\n",
> +               comp->plane, pixel_size, channels);
> +
> +        prev = ff_metal_texture_from_pixbuf(ctx, s->textureCache,
> (CVPixelBufferRef)y->prev->data[3], i, format);
> +        cur  = ff_metal_texture_from_pixbuf(ctx, s->textureCache,
> (CVPixelBufferRef)y->cur->data[3], i, format);
> +        next = ff_metal_texture_from_pixbuf(ctx, s->textureCache,
> (CVPixelBufferRef)y->next->data[3], i, format);
> +        dest = ff_metal_texture_from_pixbuf(ctx, s->textureCache,
> (CVPixelBufferRef)dst->data[3], i, format); +
> +        tex_prev = CVMetalTextureGetTexture(prev);
> +        tex_cur  = CVMetalTextureGetTexture(cur);
> +        tex_next = CVMetalTextureGetTexture(next);
> +        tex_dest = CVMetalTextureGetTexture(dest);
> +
> +        call_kernel(ctx, tex_dest, tex_prev, tex_cur, tex_next,
> +                         channels, parity, tff);
> +
> +        CFRelease(prev);
> +        CFRelease(cur);
> +        CFRelease(next);
> +        CFRelease(dest);
> +    }
> +
> +    CVBufferPropagateAttachments((CVPixelBufferRef)y->cur->data[3],
> (CVPixelBufferRef)dst->data[3]); +
> +    if (y->current_field == YADIF_FIELD_END) {
> +        y->current_field = YADIF_FIELD_NORMAL;
> +    }
> +
> +exit:
> +    return;
> +}
> +
> +static av_cold void yadif_videotoolbox_uninit(AVFilterContext *ctx)
> +{
> +    YADIFVTContext *s = ctx->priv;
> +    YADIFContext *y = &s->yadif;
> +
> +    av_frame_free(&y->prev);
> +    av_frame_free(&y->cur);
> +    av_frame_free(&y->next);
> +
> +    av_buffer_unref(&s->device_ref);
> +    av_buffer_unref(&s->input_frames_ref);
> +    s->input_frames = NULL;
> +
> +    ff_objc_release(&s->mtlParamsBuffer);
> +    ff_objc_release(&s->mtlFunction);
> +    ff_objc_release(&s->mtlPipeline);
> +    ff_objc_release(&s->mtlQueue);
> +    ff_objc_release(&s->mtlLibrary);
> +    ff_objc_release(&s->mtlDevice);
> +
> +    if (s->textureCache) {
> +        CFRelease(s->textureCache);
> +        s->textureCache = NULL;
> +    }
> +}
> +
> +static av_cold int yadif_videotoolbox_init(AVFilterContext *ctx)
> +{
> +    YADIFVTContext *s = ctx->priv;
> +    NSError *err = nil;
> +    CVReturn ret;
> +
> +    s->mtlDevice = MTLCreateSystemDefaultDevice();
> +    if (!s->mtlDevice) {
> +        av_log(ctx, AV_LOG_ERROR, "Unable to find Metal device\n");
> +        goto fail;
> +    }
> +
> +    av_log(ctx, AV_LOG_INFO, "Using Metal device: %s\n",
> s->mtlDevice.name.UTF8String); +
> +    dispatch_data_t libData = dispatch_data_create(
> +        ff_vf_yadif_videotoolbox_metallib_data,
> +        ff_vf_yadif_videotoolbox_metallib_len,
> +        nil,
> +        nil);
> +    s->mtlLibrary = [s->mtlDevice newLibraryWithData:libData
> error:&err];
> +    dispatch_release(libData);
> +    libData = nil;
> +    if (err) {
> +        av_log(ctx, AV_LOG_ERROR, "Failed to load Metal library:
> %s\n", err.description.UTF8String);
> +        goto fail;
> +    }
> +
> +    s->mtlFunction = [s->mtlLibrary newFunctionWithName:@"deint"];
> +    if (!s->mtlFunction) {
> +        av_log(ctx, AV_LOG_ERROR, "Failed to create Metal
> function!\n");
> +        goto fail;
> +    }
> +
> +    s->mtlQueue = s->mtlDevice.newCommandQueue;
> +    if (!s->mtlQueue) {
> +        av_log(ctx, AV_LOG_ERROR, "Failed to create Metal command
> queue!\n");
> +        goto fail;
> +    }
> +
> +    s->mtlPipeline = [s->mtlDevice
> +        newComputePipelineStateWithFunction:s->mtlFunction
> +        error:&err];
> +    if (err) {
> +        av_log(ctx, AV_LOG_ERROR, "Failed to create Metal compute
> pipeline: %s\n", err.description.UTF8String);
> +        goto fail;
> +    }
> +
> +    s->mtlParamsBuffer = [s->mtlDevice
> +        newBufferWithLength:sizeof(struct mtlYadifParams)
> +        options:MTLResourceStorageModeShared];
> +    if (!s->mtlParamsBuffer) {
> +        av_log(ctx, AV_LOG_ERROR, "Failed to create Metal buffer for
> parameters\n");
> +        goto fail;
> +    }
> +
> +    ret = CVMetalTextureCacheCreate(
> +        NULL,
> +        NULL,
> +        s->mtlDevice,
> +        NULL,
> +        &s->textureCache
> +    );
> +    if (ret != kCVReturnSuccess) {
> +        av_log(ctx, AV_LOG_ERROR, "Failed to create
> CVMetalTextureCache: %d\n", ret);
> +        goto fail;
> +    }
> +
> +    return 0;
> +fail:
> +    yadif_videotoolbox_uninit(ctx);
> +    return AVERROR_EXTERNAL;
> +}
> +
> +static int config_input(AVFilterLink *inlink)
> +{
> +    AVFilterContext *ctx = inlink->dst;
> +    YADIFVTContext *s = ctx->priv;
> +
> +    if (!inlink->hw_frames_ctx) {
> +        av_log(ctx, AV_LOG_ERROR, "A hardware frames reference is "
> +               "required to associate the processing device.\n");
> +        return AVERROR(EINVAL);
> +    }
> +
> +    s->input_frames_ref = av_buffer_ref(inlink->hw_frames_ctx);
> +    if (!s->input_frames_ref) {
> +        av_log(ctx, AV_LOG_ERROR, "A input frames reference create "
> +               "failed.\n");
> +        return AVERROR(ENOMEM);
> +    }
> +    s->input_frames = (AVHWFramesContext*)s->input_frames_ref->data;
> +
> +    return 0;
> +}
> +
> +static int config_output(AVFilterLink *link)
> +{
> +    AVHWFramesContext *output_frames;
> +    AVFilterContext *ctx = link->src;
> +    YADIFVTContext *s = ctx->priv;
> +    YADIFContext *y = &s->yadif;
> +    int ret = 0;
> +
> +    av_assert0(s->input_frames);
> +    s->device_ref = av_buffer_ref(s->input_frames->device_ref);
> +    if (!s->device_ref) {
> +        av_log(ctx, AV_LOG_ERROR, "A device reference create "
> +               "failed.\n");
> +        return AVERROR(ENOMEM);
> +    }
> +
> +    link->hw_frames_ctx = av_hwframe_ctx_alloc(s->device_ref);
> +    if (!link->hw_frames_ctx) {
> +        av_log(ctx, AV_LOG_ERROR, "Failed to create HW frame context
> "
> +               "for output.\n");
> +        ret = AVERROR(ENOMEM);
> +        goto exit;
> +    }
> +
> +    output_frames = (AVHWFramesContext*)link->hw_frames_ctx->data;
> +
> +    output_frames->format    = AV_PIX_FMT_VIDEOTOOLBOX;
> +    output_frames->sw_format = s->input_frames->sw_format;
> +    output_frames->width     = ctx->inputs[0]->w;
> +    output_frames->height    = ctx->inputs[0]->h;
> +
> +    ret = ff_filter_init_hw_frames(ctx, link, 10);
> +    if (ret < 0)
> +        goto exit;
> +
> +    ret = av_hwframe_ctx_init(link->hw_frames_ctx);
> +    if (ret < 0) {
> +        av_log(ctx, AV_LOG_ERROR, "Failed to initialise VideoToolbox
> frame "
> +               "context for output: %d\n", ret);
> +        goto exit;
> +    }
> +
> +    link->time_base.num = ctx->inputs[0]->time_base.num;
> +    link->time_base.den = ctx->inputs[0]->time_base.den * 2;
> +    link->w             = ctx->inputs[0]->w;
> +    link->h             = ctx->inputs[0]->h;
> +
> +    if(y->mode & 1)
> +        link->frame_rate = av_mul_q(ctx->inputs[0]->frame_rate,
> +                                    (AVRational){2, 1});
> +
> +    if (link->w < 3 || link->h < 3) {
> +        av_log(ctx, AV_LOG_ERROR, "Video of less than 3 columns or
> lines is not supported\n");
> +        ret = AVERROR(EINVAL);
> +        goto exit;
> +    }
> +
> +    y->csp = av_pix_fmt_desc_get(output_frames->sw_format);
> +    y->filter = filter;
> +
> +exit:
> +    return ret;
> +}
> +
> +#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
> +#define CONST(name, help, val, unit) { name, help, 0,
> AV_OPT_TYPE_CONST, {.i64=val}, INT_MIN, INT_MAX, FLAGS, unit } +
> +static const AVOption yadif_videotoolbox_options[] = {
> +    #define OFFSET(x) offsetof(YADIFContext, x)
> +    { "mode",   "specify the interlacing mode", OFFSET(mode),
> AV_OPT_TYPE_INT, {.i64=YADIF_MODE_SEND_FRAME}, 0, 3, FLAGS, "mode"},
> +    CONST("send_frame",           "send one frame for each frame",
>                                   YADIF_MODE_SEND_FRAME,
> "mode"),
> +    CONST("send_field",           "send one frame for each field",
>                                   YADIF_MODE_SEND_FIELD,
> "mode"),
> +    CONST("send_frame_nospatial", "send one frame for each frame,
> but skip spatial interlacing check", YADIF_MODE_SEND_FRAME_NOSPATIAL,
> "mode"),
> +    CONST("send_field_nospatial", "send one frame for each field,
> but skip spatial interlacing check", YADIF_MODE_SEND_FIELD_NOSPATIAL,
> "mode"), +
> +    { "parity", "specify the assumed picture field parity",
> OFFSET(parity), AV_OPT_TYPE_INT, {.i64=YADIF_PARITY_AUTO}, -1, 1,
> FLAGS, "parity" },
> +    CONST("tff",  "assume top field first",    YADIF_PARITY_TFF,
> "parity"),
> +    CONST("bff",  "assume bottom field first", YADIF_PARITY_BFF,
> "parity"),
> +    CONST("auto", "auto detect parity",        YADIF_PARITY_AUTO,
> "parity"), +
> +    { "deint", "specify which frames to deinterlace", OFFSET(deint),
> AV_OPT_TYPE_INT, {.i64=YADIF_DEINT_ALL}, 0, 1, FLAGS, "deint" },
> +    CONST("all",        "deinterlace all frames",
>    YADIF_DEINT_ALL,        "deint"),
> +    CONST("interlaced", "only deinterlace frames marked as
> interlaced", YADIF_DEINT_INTERLACED, "deint"),
> +    #undef OFFSET
> +
> +    { NULL }
> +};
> +
> +AVFILTER_DEFINE_CLASS(yadif_videotoolbox);
> +
> +static const AVFilterPad yadif_videotoolbox_inputs[] = {
> +    {
> +        .name          = "default",
> +        .type          = AVMEDIA_TYPE_VIDEO,
> +        .filter_frame  = ff_yadif_filter_frame,
> +        .config_props  = config_input,
> +    },
> +};
> +
> +static const AVFilterPad yadif_videotoolbox_outputs[] = {
> +    {
> +        .name          = "default",
> +        .type          = AVMEDIA_TYPE_VIDEO,
> +        .request_frame = ff_yadif_request_frame,
> +        .config_props  = config_output,
> +    },
> +};
> +
> +AVFilter ff_vf_yadif_videotoolbox = {
> +    .name           = "yadif_videotoolbox",
> +    .description    = NULL_IF_CONFIG_SMALL("YADIF for VideoToolbox
> frames using Metal compute"),
> +    .priv_size      = sizeof(YADIFVTContext),
> +    .priv_class     = &yadif_videotoolbox_class,
> +    .init           = yadif_videotoolbox_init,
> +    .uninit         = yadif_videotoolbox_uninit,
> +    FILTER_SINGLE_PIXFMT(AV_PIX_FMT_VIDEOTOOLBOX),
> +    FILTER_INPUTS(yadif_videotoolbox_inputs),
> +    FILTER_OUTPUTS(yadif_videotoolbox_outputs),
> +    .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
> +    .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
> +};

LGTM for the general part. I'll take your work that the metal specific
parts work as intended.

--phil
_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

Re: [FFmpeg-devel] [PATCH v4 5/5] avfilter: add vf_yadif_videotoolbox

[Aman Karmani]

On Fri, Dec 17, 2021 at 1:38 PM Philip Langdale <philipl@overt.org> wrote:

> On Fri, 17 Dec 2021 12:04:18 -0800
> Aman Karmani <ffmpeg@tmm1.net> wrote:
>
> > From: Aman Karmani <aman@tmm1.net>
> >
> > deinterlaces CVPixelBuffers, i.e. AV_PIX_FMT_VIDEOTOOLBOX frames
> >
> > for example, an interlaced mpeg2 video can be decoded by avcodec,
> > uploaded into a CVPixelBuffer, deinterlaced by Metal, and then
> > encoded to h264 by VideoToolbox as follows:
> >
> >     ffmpeg \
> >            -init_hw_device videotoolbox \
> >            -i interlaced.ts \
> >            -vf hwupload,yadif_videotoolbox \
> >            -c:v h264_videotoolbox \
> >            -b:v 2000k \
> >            -c:a copy \
> >            -y progressive.ts
> >
> > (note that uploading AVFrame into CVPixelBuffer via hwupload
> >  requires 504c60660d3194758823ddd45ceddb86e35d806f)
> >
> > this work is sponsored by Fancy Bits LLC
> >
> > Reviewed-by: Ridley Combs <rcombs@rcombs.me>
> > Signed-off-by: Aman Karmani <aman@tmm1.net>
> > ---
> >  configure                                     |   1 +
> >  libavfilter/Makefile                          |   4 +
> >  libavfilter/allfilters.c                      |   1 +
> >  libavfilter/metal/vf_yadif_videotoolbox.metal | 269 ++++++++++++
> >  libavfilter/vf_yadif_videotoolbox.m           | 406
> > ++++++++++++++++++ 5 files changed, 681 insertions(+)
> >  create mode 100644 libavfilter/metal/vf_yadif_videotoolbox.metal
> >  create mode 100644 libavfilter/vf_yadif_videotoolbox.m
> >
> > diff --git a/configure b/configure
> > index 32a39f5f5b..d8b07c8e00 100755
> > --- a/configure
> > +++ b/configure
> > @@ -3748,6 +3748,7 @@ vpp_qsv_filter_select="qsvvpp"
> >  xfade_opencl_filter_deps="opencl"
> >  yadif_cuda_filter_deps="ffnvcodec"
> >  yadif_cuda_filter_deps_any="cuda_nvcc cuda_llvm"
> > +yadif_videotoolbox_filter_deps="metal corevideo videotoolbox"
> >
> >  # examples
> >  avio_list_dir_deps="avformat avutil"
> > diff --git a/libavfilter/Makefile b/libavfilter/Makefile
> > index 2fe495df28..9a061ba3c8 100644
> > --- a/libavfilter/Makefile
> > +++ b/libavfilter/Makefile
> > @@ -519,6 +519,10 @@ OBJS-$(CONFIG_XSTACK_FILTER)                 +=
> > vf_stack.o framesync.o OBJS-$(CONFIG_YADIF_FILTER)
> > += vf_yadif.o yadif_common.o OBJS-$(CONFIG_YADIF_CUDA_FILTER)
> >     += vf_yadif_cuda.o vf_yadif_cuda.ptx.o \ yadif_common.o
> > cuda/load_helper.o +OBJS-$(CONFIG_YADIF_VIDEOTOOLBOX_FILTER)     +=
> > vf_yadif_videotoolbox.o \
> > +
> > metal/vf_yadif_videotoolbox.metallib.o \
> > +                                                metal/utils.o \
> > +                                                yadif_common.o
> >  OBJS-$(CONFIG_YAEPBLUR_FILTER)               += vf_yaepblur.o
> >  OBJS-$(CONFIG_ZMQ_FILTER)                    += f_zmq.o
> >  OBJS-$(CONFIG_ZOOMPAN_FILTER)                += vf_zoompan.o
> > diff --git a/libavfilter/allfilters.c b/libavfilter/allfilters.c
> > index ec57a2c49c..26f1c73505 100644
> > --- a/libavfilter/allfilters.c
> > +++ b/libavfilter/allfilters.c
> > @@ -496,6 +496,7 @@ extern const AVFilter ff_vf_xmedian;
> >  extern const AVFilter ff_vf_xstack;
> >  extern const AVFilter ff_vf_yadif;
> >  extern const AVFilter ff_vf_yadif_cuda;
> > +extern const AVFilter ff_vf_yadif_videotoolbox;
> >  extern const AVFilter ff_vf_yaepblur;
> >  extern const AVFilter ff_vf_zmq;
> >  extern const AVFilter ff_vf_zoompan;
> > diff --git a/libavfilter/metal/vf_yadif_videotoolbox.metal
> > b/libavfilter/metal/vf_yadif_videotoolbox.metal new file mode 100644
> > index 0000000000..50783f2ffe
> > --- /dev/null
> > +++ b/libavfilter/metal/vf_yadif_videotoolbox.metal
> > @@ -0,0 +1,269 @@
> > +/*
> > + * Copyright (C) 2018 Philip Langdale <philipl@overt.org>
> > + *               2020 Aman Karmani <aman@tmm1.net>
> > + *               2020 Stefan Dyulgerov <stefan.dyulgerov@gmail.com>
> > + *
> > + * 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 FFmpeg; if not, write to the Free Software
> > + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
> > 02110-1301 USA
> > + */
> > +
> > +#include <metal_stdlib>
> > +#include <metal_integer>
> > +#include <metal_texture>
> > +
> > +using namespace metal;
> > +
> > +/*
> > + * Parameters
> > + */
> > +
> > +struct deintParams {
> > +    uint channels;
> > +    uint parity;
> > +    uint tff;
> > +    bool is_second_field;
> > +    bool skip_spatial_check;
> > +    int field_mode;
> > +};
> > +
> > +/*
> > + * Texture access helpers
> > + */
> > +
> > +#define accesstype access::sample
> > +const sampler s(coord::pixel);
> > +
> > +template <typename T>
> > +T tex2D(texture2d<float, access::sample> tex, uint x, uint y)
> > +{
> > +    return tex.sample(s, float2(x, y)).x;
> > +}
> > +
> > +template <>
> > +float2 tex2D<float2>(texture2d<float, access::sample> tex, uint x,
> > uint y) +{
> > +    return tex.sample(s, float2(x, y)).xy;
> > +}
> > +
> > +template <typename T>
> > +T tex2D(texture2d<float, access::read> tex, uint x, uint y)
> > +{
> > +    return tex.read(uint2(x, y)).x;
> > +}
> > +
> > +template <>
> > +float2 tex2D<float2>(texture2d<float, access::read> tex, uint x,
> > uint y) +{
> > +    return tex.read(uint2(x, y)).xy;
> > +}
> > +
> > +/*
> > + * YADIF helpers
> > + */
> > +
> > +template<typename T>
> > +T spatial_predictor(T a, T b, T c, T d, T e, T f, T g,
> > +                    T h, T i, T j, T k, T l, T m, T n)
> > +{
> > +    T spatial_pred = (d + k)/2;
> > +    T spatial_score = abs(c - j) + abs(d - k) + abs(e - l);
> > +
> > +    T score = abs(b - k) + abs(c - l) + abs(d - m);
> > +    if (score < spatial_score) {
> > +        spatial_pred = (c + l)/2;
> > +        spatial_score = score;
> > +        score = abs(a - l) + abs(b - m) + abs(c - n);
> > +        if (score < spatial_score) {
> > +            spatial_pred = (b + m)/2;
> > +            spatial_score = score;
> > +        }
> > +    }
> > +    score = abs(d - i) + abs(e - j) + abs(f - k);
> > +    if (score < spatial_score) {
> > +        spatial_pred = (e + j)/2;
> > +        spatial_score = score;
> > +        score = abs(e - h) + abs(f - i) + abs(g - j);
> > +        if (score < spatial_score) {
> > +            spatial_pred = (f + i)/2;
> > +            spatial_score = score;
> > +        }
> > +    }
> > +    return spatial_pred;
> > +}
> > +
> > +template<typename T>
> > +T temporal_predictor(T A, T B, T C, T D, T E, T F,
> > +                     T G, T H, T I, T J, T K, T L,
> > +                     T spatial_pred, bool skip_check)
> > +{
> > +    T p0 = (C + H) / 2;
> > +    T p1 = F;
> > +    T p2 = (D + I) / 2;
> > +    T p3 = G;
> > +    T p4 = (E + J) / 2;
> > +
> > +    T tdiff0 = abs(D - I);
> > +    T tdiff1 = (abs(A - F) + abs(B - G)) / 2;
> > +    T tdiff2 = (abs(K - F) + abs(G - L)) / 2;
> > +
> > +    T diff = max3(tdiff0, tdiff1, tdiff2);
> > +
> > +    if (!skip_check) {
> > +        T maxi = max3(p2 - p3, p2 - p1, min(p0 - p1, p4 - p3));
> > +        T mini = min3(p2 - p3, p2 - p1, max(p0 - p1, p4 - p3));
> > +        diff = max3(diff, mini, -maxi);
> > +    }
> > +
> > +    return clamp(spatial_pred, p2 - diff, p2 + diff);
> > +}
> > +
> > +#define T float2
> > +template <>
> > +T spatial_predictor<T>(T a, T b, T c, T d, T e, T f, T g,
> > +                       T h, T i, T j, T k, T l, T m, T n)
> > +{
> > +    return T(
> > +        spatial_predictor(a.x, b.x, c.x, d.x, e.x, f.x, g.x,
> > +                          h.x, i.x, j.x, k.x, l.x, m.x, n.x),
> > +        spatial_predictor(a.y, b.y, c.y, d.y, e.y, f.y, g.y,
> > +                          h.y, i.y, j.y, k.y, l.y, m.y, n.y)
> > +    );
> > +}
> > +
> > +template <>
> > +T temporal_predictor<T>(T A, T B, T C, T D, T E, T F,
> > +                        T G, T H, T I, T J, T K, T L,
> > +                        T spatial_pred, bool skip_check)
> > +{
> > +    return T(
> > +        temporal_predictor(A.x, B.x, C.x, D.x, E.x, F.x,
> > +                           G.x, H.x, I.x, J.x, K.x, L.x,
> > +                           spatial_pred.x, skip_check),
> > +        temporal_predictor(A.y, B.y, C.y, D.y, E.y, F.y,
> > +                           G.y, H.y, I.y, J.y, K.y, L.y,
> > +                           spatial_pred.y, skip_check)
> > +    );
> > +}
> > +#undef T
> > +
> > +/*
> > + * YADIF compute
> > + */
> > +
> > +template <typename T>
> > +T yadif_compute_spatial(
> > +    texture2d<float, accesstype> cur,
> > +    uint2 pos)
> > +{
> > +    // Calculate spatial prediction
> > +    T a = tex2D<T>(cur, pos.x - 3, pos.y - 1);
> > +    T b = tex2D<T>(cur, pos.x - 2, pos.y - 1);
> > +    T c = tex2D<T>(cur, pos.x - 1, pos.y - 1);
> > +    T d = tex2D<T>(cur, pos.x - 0, pos.y - 1);
> > +    T e = tex2D<T>(cur, pos.x + 1, pos.y - 1);
> > +    T f = tex2D<T>(cur, pos.x + 2, pos.y - 1);
> > +    T g = tex2D<T>(cur, pos.x + 3, pos.y - 1);
> > +
> > +    T h = tex2D<T>(cur, pos.x - 3, pos.y + 1);
> > +    T i = tex2D<T>(cur, pos.x - 2, pos.y + 1);
> > +    T j = tex2D<T>(cur, pos.x - 1, pos.y + 1);
> > +    T k = tex2D<T>(cur, pos.x - 0, pos.y + 1);
> > +    T l = tex2D<T>(cur, pos.x + 1, pos.y + 1);
> > +    T m = tex2D<T>(cur, pos.x + 2, pos.y + 1);
> > +    T n = tex2D<T>(cur, pos.x + 3, pos.y + 1);
> > +
> > +    return spatial_predictor(a, b, c, d, e, f, g,
> > +                             h, i, j, k, l, m, n);
> > +}
> > +
> > +template <typename T>
> > +T yadif_compute_temporal(
> > +    texture2d<float, accesstype> cur,
> > +    texture2d<float, accesstype> prev2,
> > +    texture2d<float, accesstype> prev1,
> > +    texture2d<float, accesstype> next1,
> > +    texture2d<float, accesstype> next2,
> > +    T spatial_pred,
> > +    bool skip_spatial_check,
> > +    uint2 pos)
> > +{
> > +    // Calculate temporal prediction
> > +    T A = tex2D<T>(prev2, pos.x, pos.y - 1);
> > +    T B = tex2D<T>(prev2, pos.x, pos.y + 1);
> > +    T C = tex2D<T>(prev1, pos.x, pos.y - 2);
> > +    T D = tex2D<T>(prev1, pos.x, pos.y + 0);
> > +    T E = tex2D<T>(prev1, pos.x, pos.y + 2);
> > +    T F = tex2D<T>(cur,   pos.x, pos.y - 1);
> > +    T G = tex2D<T>(cur,   pos.x, pos.y + 1);
> > +    T H = tex2D<T>(next1, pos.x, pos.y - 2);
> > +    T I = tex2D<T>(next1, pos.x, pos.y + 0);
> > +    T J = tex2D<T>(next1, pos.x, pos.y + 2);
> > +    T K = tex2D<T>(next2, pos.x, pos.y - 1);
> > +    T L = tex2D<T>(next2, pos.x, pos.y + 1);
> > +
> > +    return temporal_predictor(A, B, C, D, E, F, G, H, I, J, K, L,
> > +                              spatial_pred, skip_spatial_check);
> > +}
> > +
> > +template <typename T>
> > +T yadif(
> > +    texture2d<float, access::write> dst,
> > +    texture2d<float, accesstype> prev,
> > +    texture2d<float, accesstype> cur,
> > +    texture2d<float, accesstype> next,
> > +    constant deintParams& params,
> > +    uint2 pos)
> > +{
> > +    T spatial_pred = yadif_compute_spatial<T>(cur, pos);
> > +
> > +    if (params.is_second_field) {
> > +        return yadif_compute_temporal(cur, prev, cur, next, next,
> > spatial_pred, params.skip_spatial_check, pos);
> > +    } else {
> > +        return yadif_compute_temporal(cur, prev, prev, cur, next,
> > spatial_pred, params.skip_spatial_check, pos);
> > +    }
> > +}
> > +
> > +/*
> > + * Kernel dispatch
> > + */
> > +
> > +kernel void deint(
> > +    texture2d<float, access::write> dst [[texture(0)]],
> > +    texture2d<float, accesstype> prev [[texture(1)]],
> > +    texture2d<float, accesstype> cur  [[texture(2)]],
> > +    texture2d<float, accesstype> next [[texture(3)]],
> > +    constant deintParams& params [[buffer(4)]],
> > +    uint2 pos [[thread_position_in_grid]])
> > +{
> > +    if ((pos.x >= dst.get_width()) ||
> > +        (pos.y >= dst.get_height())) {
> > +        return;
> > +    }
> > +
> > +    // Don't modify the primary field
> > +    if (pos.y % 2 == params.parity) {
> > +        float4 in = cur.read(pos);
> > +        dst.write(in, pos);
> > +        return;
> > +    }
> > +
> > +    float2 pred;
> > +    if (params.channels == 1)
> > +        pred = float2(yadif<float>(dst, prev, cur, next, params,
> > pos));
> > +    else
> > +        pred = yadif<float2>(dst, prev, cur, next, params, pos);
> > +    dst.write(pred.xyyy, pos);
> > +}
> > diff --git a/libavfilter/vf_yadif_videotoolbox.m
> > b/libavfilter/vf_yadif_videotoolbox.m new file mode 100644
> > index 0000000000..af83a73e89
> > --- /dev/null
> > +++ b/libavfilter/vf_yadif_videotoolbox.m
> > @@ -0,0 +1,406 @@
> > +/*
> > + * Copyright (C) 2018 Philip Langdale <philipl@overt.org>
> > + *               2020 Aman Karmani <aman@tmm1.net>
> > + *
> > + * 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 FFmpeg; if not, write to the Free Software
> > + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
> > 02110-1301 USA
> > + */
> > +
> > +#include "internal.h"
> > +#include "yadif.h"
> > +#include <libavutil/avassert.h>
> > +#include <libavutil/hwcontext.h>
> > +#include <libavutil/objc.h>
> > +#include <libavfilter/metal/utils.h>
> > +
> > +extern char ff_vf_yadif_videotoolbox_metallib_data[];
> > +extern unsigned int ff_vf_yadif_videotoolbox_metallib_len;
> > +
> > +typedef struct YADIFVTContext {
> > +    YADIFContext yadif;
> > +
> > +    AVBufferRef       *device_ref;
> > +    AVBufferRef       *input_frames_ref;
> > +    AVHWFramesContext *input_frames;
> > +
> > +    id<MTLDevice> mtlDevice;
> > +    id<MTLLibrary> mtlLibrary;
> > +    id<MTLCommandQueue> mtlQueue;
> > +    id<MTLComputePipelineState> mtlPipeline;
> > +    id<MTLFunction> mtlFunction;
> > +    id<MTLBuffer> mtlParamsBuffer;
> > +
> > +    CVMetalTextureCacheRef textureCache;
> > +} YADIFVTContext;
> > +
> > +struct mtlYadifParams {
> > +    uint channels;
> > +    uint parity;
> > +    uint tff;
> > +    bool is_second_field;
> > +    bool skip_spatial_check;
> > +    int field_mode;
> > +};
> > +
> > +static void call_kernel(AVFilterContext *ctx,
> > +                        id<MTLTexture> dst,
> > +                        id<MTLTexture> prev,
> > +                        id<MTLTexture> cur,
> > +                        id<MTLTexture> next,
> > +                        int channels,
> > +                        int parity,
> > +                        int tff)
> > +{
> > +    YADIFVTContext *s = ctx->priv;
> > +    id<MTLCommandBuffer> buffer = s->mtlQueue.commandBuffer;
> > +    id<MTLComputeCommandEncoder> encoder =
> > buffer.computeCommandEncoder;
> > +    struct mtlYadifParams *params = (struct mtlYadifParams
> > *)s->mtlParamsBuffer.contents;
> > +    *params = (struct mtlYadifParams){
> > +        .channels = channels,
> > +        .parity = parity,
> > +        .tff = tff,
> > +        .is_second_field = !(parity ^ tff),
> > +        .skip_spatial_check = s->yadif.mode&2,
> > +        .field_mode = s->yadif.current_field
> > +    };
> > +
> > +    [encoder setTexture:dst  atIndex:0];
> > +    [encoder setTexture:prev atIndex:1];
> > +    [encoder setTexture:cur  atIndex:2];
> > +    [encoder setTexture:next atIndex:3];
> > +    [encoder setBuffer:s->mtlParamsBuffer offset:0 atIndex:4];
> > +    ff_metal_compute_encoder_dispatch(s->mtlDevice, s->mtlPipeline,
> > encoder, dst.width, dst.height);
> > +    [encoder endEncoding];
> > +
> > +    [buffer commit];
> > +    [buffer waitUntilCompleted];
> > +
> > +    ff_objc_release(&encoder);
> > +    ff_objc_release(&buffer);
> > +}
> > +
> > +static void filter(AVFilterContext *ctx, AVFrame *dst,
> > +                   int parity, int tff)
> > +{
> > +    YADIFVTContext *s = ctx->priv;
> > +    YADIFContext *y = &s->yadif;
> > +    int i;
> > +
> > +    for (i = 0; i < y->csp->nb_components; i++) {
> > +        int pixel_size, channels;
> > +        const AVComponentDescriptor *comp = &y->csp->comp[i];
> > +        CVMetalTextureRef prev, cur, next, dest;
> > +        id<MTLTexture> tex_prev, tex_cur, tex_next, tex_dest;
> > +        MTLPixelFormat format;
> > +
> > +        if (comp->plane < i) {
> > +            // We process planes as a whole, so don't reprocess
> > +            // them for additional components
> > +            continue;
> > +        }
> > +
> > +        pixel_size = (comp->depth + comp->shift) / 8;
> > +        channels = comp->step / pixel_size;
> > +        if (pixel_size > 2 || channels > 2) {
> > +            av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format:
> > %s\n", y->csp->name);
> > +            goto exit;
> > +        }
> > +        switch (pixel_size) {
> > +        case 1:
> > +            format = channels == 1 ? MTLPixelFormatR8Unorm :
> > MTLPixelFormatRG8Unorm;
> > +            break;
> > +        case 2:
> > +            format = channels == 1 ? MTLPixelFormatR16Unorm :
> > MTLPixelFormatRG16Unorm;
> > +            break;
> > +        default:
> > +            av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format:
> > %s\n", y->csp->name);
> > +            goto exit;
> > +        }
> > +        av_log(ctx, AV_LOG_TRACE,
> > +               "Deinterlacing plane %d: pixel_size: %d channels:
> > %d\n",
> > +               comp->plane, pixel_size, channels);
> > +
> > +        prev = ff_metal_texture_from_pixbuf(ctx, s->textureCache,
> > (CVPixelBufferRef)y->prev->data[3], i, format);
> > +        cur  = ff_metal_texture_from_pixbuf(ctx, s->textureCache,
> > (CVPixelBufferRef)y->cur->data[3], i, format);
> > +        next = ff_metal_texture_from_pixbuf(ctx, s->textureCache,
> > (CVPixelBufferRef)y->next->data[3], i, format);
> > +        dest = ff_metal_texture_from_pixbuf(ctx, s->textureCache,
> > (CVPixelBufferRef)dst->data[3], i, format); +
> > +        tex_prev = CVMetalTextureGetTexture(prev);
> > +        tex_cur  = CVMetalTextureGetTexture(cur);
> > +        tex_next = CVMetalTextureGetTexture(next);
> > +        tex_dest = CVMetalTextureGetTexture(dest);
> > +
> > +        call_kernel(ctx, tex_dest, tex_prev, tex_cur, tex_next,
> > +                         channels, parity, tff);
> > +
> > +        CFRelease(prev);
> > +        CFRelease(cur);
> > +        CFRelease(next);
> > +        CFRelease(dest);
> > +    }
> > +
> > +    CVBufferPropagateAttachments((CVPixelBufferRef)y->cur->data[3],
> > (CVPixelBufferRef)dst->data[3]); +
> > +    if (y->current_field == YADIF_FIELD_END) {
> > +        y->current_field = YADIF_FIELD_NORMAL;
> > +    }
> > +
> > +exit:
> > +    return;
> > +}
> > +
> > +static av_cold void yadif_videotoolbox_uninit(AVFilterContext *ctx)
> > +{
> > +    YADIFVTContext *s = ctx->priv;
> > +    YADIFContext *y = &s->yadif;
> > +
> > +    av_frame_free(&y->prev);
> > +    av_frame_free(&y->cur);
> > +    av_frame_free(&y->next);
> > +
> > +    av_buffer_unref(&s->device_ref);
> > +    av_buffer_unref(&s->input_frames_ref);
> > +    s->input_frames = NULL;
> > +
> > +    ff_objc_release(&s->mtlParamsBuffer);
> > +    ff_objc_release(&s->mtlFunction);
> > +    ff_objc_release(&s->mtlPipeline);
> > +    ff_objc_release(&s->mtlQueue);
> > +    ff_objc_release(&s->mtlLibrary);
> > +    ff_objc_release(&s->mtlDevice);
> > +
> > +    if (s->textureCache) {
> > +        CFRelease(s->textureCache);
> > +        s->textureCache = NULL;
> > +    }
> > +}
> > +
> > +static av_cold int yadif_videotoolbox_init(AVFilterContext *ctx)
> > +{
> > +    YADIFVTContext *s = ctx->priv;
> > +    NSError *err = nil;
> > +    CVReturn ret;
> > +
> > +    s->mtlDevice = MTLCreateSystemDefaultDevice();
> > +    if (!s->mtlDevice) {
> > +        av_log(ctx, AV_LOG_ERROR, "Unable to find Metal device\n");
> > +        goto fail;
> > +    }
> > +
> > +    av_log(ctx, AV_LOG_INFO, "Using Metal device: %s\n",
> > s->mtlDevice.name.UTF8String); +
> > +    dispatch_data_t libData = dispatch_data_create(
> > +        ff_vf_yadif_videotoolbox_metallib_data,
> > +        ff_vf_yadif_videotoolbox_metallib_len,
> > +        nil,
> > +        nil);
> > +    s->mtlLibrary = [s->mtlDevice newLibraryWithData:libData
> > error:&err];
> > +    dispatch_release(libData);
> > +    libData = nil;
> > +    if (err) {
> > +        av_log(ctx, AV_LOG_ERROR, "Failed to load Metal library:
> > %s\n", err.description.UTF8String);
> > +        goto fail;
> > +    }
> > +
> > +    s->mtlFunction = [s->mtlLibrary newFunctionWithName:@"deint"];
> > +    if (!s->mtlFunction) {
> > +        av_log(ctx, AV_LOG_ERROR, "Failed to create Metal
> > function!\n");
> > +        goto fail;
> > +    }
> > +
> > +    s->mtlQueue = s->mtlDevice.newCommandQueue;
> > +    if (!s->mtlQueue) {
> > +        av_log(ctx, AV_LOG_ERROR, "Failed to create Metal command
> > queue!\n");
> > +        goto fail;
> > +    }
> > +
> > +    s->mtlPipeline = [s->mtlDevice
> > +        newComputePipelineStateWithFunction:s->mtlFunction
> > +        error:&err];
> > +    if (err) {
> > +        av_log(ctx, AV_LOG_ERROR, "Failed to create Metal compute
> > pipeline: %s\n", err.description.UTF8String);
> > +        goto fail;
> > +    }
> > +
> > +    s->mtlParamsBuffer = [s->mtlDevice
> > +        newBufferWithLength:sizeof(struct mtlYadifParams)
> > +        options:MTLResourceStorageModeShared];
> > +    if (!s->mtlParamsBuffer) {
> > +        av_log(ctx, AV_LOG_ERROR, "Failed to create Metal buffer for
> > parameters\n");
> > +        goto fail;
> > +    }
> > +
> > +    ret = CVMetalTextureCacheCreate(
> > +        NULL,
> > +        NULL,
> > +        s->mtlDevice,
> > +        NULL,
> > +        &s->textureCache
> > +    );
> > +    if (ret != kCVReturnSuccess) {
> > +        av_log(ctx, AV_LOG_ERROR, "Failed to create
> > CVMetalTextureCache: %d\n", ret);
> > +        goto fail;
> > +    }
> > +
> > +    return 0;
> > +fail:
> > +    yadif_videotoolbox_uninit(ctx);
> > +    return AVERROR_EXTERNAL;
> > +}
> > +
> > +static int config_input(AVFilterLink *inlink)
> > +{
> > +    AVFilterContext *ctx = inlink->dst;
> > +    YADIFVTContext *s = ctx->priv;
> > +
> > +    if (!inlink->hw_frames_ctx) {
> > +        av_log(ctx, AV_LOG_ERROR, "A hardware frames reference is "
> > +               "required to associate the processing device.\n");
> > +        return AVERROR(EINVAL);
> > +    }
> > +
> > +    s->input_frames_ref = av_buffer_ref(inlink->hw_frames_ctx);
> > +    if (!s->input_frames_ref) {
> > +        av_log(ctx, AV_LOG_ERROR, "A input frames reference create "
> > +               "failed.\n");
> > +        return AVERROR(ENOMEM);
> > +    }
> > +    s->input_frames = (AVHWFramesContext*)s->input_frames_ref->data;
> > +
> > +    return 0;
> > +}
> > +
> > +static int config_output(AVFilterLink *link)
> > +{
> > +    AVHWFramesContext *output_frames;
> > +    AVFilterContext *ctx = link->src;
> > +    YADIFVTContext *s = ctx->priv;
> > +    YADIFContext *y = &s->yadif;
> > +    int ret = 0;
> > +
> > +    av_assert0(s->input_frames);
> > +    s->device_ref = av_buffer_ref(s->input_frames->device_ref);
> > +    if (!s->device_ref) {
> > +        av_log(ctx, AV_LOG_ERROR, "A device reference create "
> > +               "failed.\n");
> > +        return AVERROR(ENOMEM);
> > +    }
> > +
> > +    link->hw_frames_ctx = av_hwframe_ctx_alloc(s->device_ref);
> > +    if (!link->hw_frames_ctx) {
> > +        av_log(ctx, AV_LOG_ERROR, "Failed to create HW frame context
> > "
> > +               "for output.\n");
> > +        ret = AVERROR(ENOMEM);
> > +        goto exit;
> > +    }
> > +
> > +    output_frames = (AVHWFramesContext*)link->hw_frames_ctx->data;
> > +
> > +    output_frames->format    = AV_PIX_FMT_VIDEOTOOLBOX;
> > +    output_frames->sw_format = s->input_frames->sw_format;
> > +    output_frames->width     = ctx->inputs[0]->w;
> > +    output_frames->height    = ctx->inputs[0]->h;
> > +
> > +    ret = ff_filter_init_hw_frames(ctx, link, 10);
> > +    if (ret < 0)
> > +        goto exit;
> > +
> > +    ret = av_hwframe_ctx_init(link->hw_frames_ctx);
> > +    if (ret < 0) {
> > +        av_log(ctx, AV_LOG_ERROR, "Failed to initialise VideoToolbox
> > frame "
> > +               "context for output: %d\n", ret);
> > +        goto exit;
> > +    }
> > +
> > +    link->time_base.num = ctx->inputs[0]->time_base.num;
> > +    link->time_base.den = ctx->inputs[0]->time_base.den * 2;
> > +    link->w             = ctx->inputs[0]->w;
> > +    link->h             = ctx->inputs[0]->h;
> > +
> > +    if(y->mode & 1)
> > +        link->frame_rate = av_mul_q(ctx->inputs[0]->frame_rate,
> > +                                    (AVRational){2, 1});
> > +
> > +    if (link->w < 3 || link->h < 3) {
> > +        av_log(ctx, AV_LOG_ERROR, "Video of less than 3 columns or
> > lines is not supported\n");
> > +        ret = AVERROR(EINVAL);
> > +        goto exit;
> > +    }
> > +
> > +    y->csp = av_pix_fmt_desc_get(output_frames->sw_format);
> > +    y->filter = filter;
> > +
> > +exit:
> > +    return ret;
> > +}
> > +
> > +#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
> > +#define CONST(name, help, val, unit) { name, help, 0,
> > AV_OPT_TYPE_CONST, {.i64=val}, INT_MIN, INT_MAX, FLAGS, unit } +
> > +static const AVOption yadif_videotoolbox_options[] = {
> > +    #define OFFSET(x) offsetof(YADIFContext, x)
> > +    { "mode",   "specify the interlacing mode", OFFSET(mode),
> > AV_OPT_TYPE_INT, {.i64=YADIF_MODE_SEND_FRAME}, 0, 3, FLAGS, "mode"},
> > +    CONST("send_frame",           "send one frame for each frame",
> >                                   YADIF_MODE_SEND_FRAME,
> > "mode"),
> > +    CONST("send_field",           "send one frame for each field",
> >                                   YADIF_MODE_SEND_FIELD,
> > "mode"),
> > +    CONST("send_frame_nospatial", "send one frame for each frame,
> > but skip spatial interlacing check", YADIF_MODE_SEND_FRAME_NOSPATIAL,
> > "mode"),
> > +    CONST("send_field_nospatial", "send one frame for each field,
> > but skip spatial interlacing check", YADIF_MODE_SEND_FIELD_NOSPATIAL,
> > "mode"), +
> > +    { "parity", "specify the assumed picture field parity",
> > OFFSET(parity), AV_OPT_TYPE_INT, {.i64=YADIF_PARITY_AUTO}, -1, 1,
> > FLAGS, "parity" },
> > +    CONST("tff",  "assume top field first",    YADIF_PARITY_TFF,
> > "parity"),
> > +    CONST("bff",  "assume bottom field first", YADIF_PARITY_BFF,
> > "parity"),
> > +    CONST("auto", "auto detect parity",        YADIF_PARITY_AUTO,
> > "parity"), +
> > +    { "deint", "specify which frames to deinterlace", OFFSET(deint),
> > AV_OPT_TYPE_INT, {.i64=YADIF_DEINT_ALL}, 0, 1, FLAGS, "deint" },
> > +    CONST("all",        "deinterlace all frames",
> >    YADIF_DEINT_ALL,        "deint"),
> > +    CONST("interlaced", "only deinterlace frames marked as
> > interlaced", YADIF_DEINT_INTERLACED, "deint"),
> > +    #undef OFFSET
> > +
> > +    { NULL }
> > +};
> > +
> > +AVFILTER_DEFINE_CLASS(yadif_videotoolbox);
> > +
> > +static const AVFilterPad yadif_videotoolbox_inputs[] = {
> > +    {
> > +        .name          = "default",
> > +        .type          = AVMEDIA_TYPE_VIDEO,
> > +        .filter_frame  = ff_yadif_filter_frame,
> > +        .config_props  = config_input,
> > +    },
> > +};
> > +
> > +static const AVFilterPad yadif_videotoolbox_outputs[] = {
> > +    {
> > +        .name          = "default",
> > +        .type          = AVMEDIA_TYPE_VIDEO,
> > +        .request_frame = ff_yadif_request_frame,
> > +        .config_props  = config_output,
> > +    },
> > +};
> > +
> > +AVFilter ff_vf_yadif_videotoolbox = {
> > +    .name           = "yadif_videotoolbox",
> > +    .description    = NULL_IF_CONFIG_SMALL("YADIF for VideoToolbox
> > frames using Metal compute"),
> > +    .priv_size      = sizeof(YADIFVTContext),
> > +    .priv_class     = &yadif_videotoolbox_class,
> > +    .init           = yadif_videotoolbox_init,
> > +    .uninit         = yadif_videotoolbox_uninit,
> > +    FILTER_SINGLE_PIXFMT(AV_PIX_FMT_VIDEOTOOLBOX),
> > +    FILTER_INPUTS(yadif_videotoolbox_inputs),
> > +    FILTER_OUTPUTS(yadif_videotoolbox_outputs),
> > +    .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
> > +    .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
> > +};
>
> LGTM for the general part. I'll take your work that the metal specific
> parts work as intended.
>

Patchset applied. Thanks to everyone who helped review on and off-list.


>
> --phil
>
_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

Re: [FFmpeg-devel] [PATCH v4 5/5] avfilter: add vf_yadif_videotoolbox

[Pavel Koshevoy]

On Sat, Dec 18, 2021 at 1:02 PM Aman Karmani <ffmpeg@tmm1.net> wrote:

> On Fri, Dec 17, 2021 at 1:38 PM Philip Langdale <philipl@overt.org> wrote:
>
> > On Fri, 17 Dec 2021 12:04:18 -0800
> > Aman Karmani <ffmpeg@tmm1.net> wrote:
> >
> > > From: Aman Karmani <aman@tmm1.net>
> > >
> > > deinterlaces CVPixelBuffers, i.e. AV_PIX_FMT_VIDEOTOOLBOX frames
> > >
> > > for example, an interlaced mpeg2 video can be decoded by avcodec,
> > > uploaded into a CVPixelBuffer, deinterlaced by Metal, and then
> > > encoded to h264 by VideoToolbox as follows:
> > >
> > >     ffmpeg \
> > >            -init_hw_device videotoolbox \
> > >            -i interlaced.ts \
> > >            -vf hwupload,yadif_videotoolbox \
> > >            -c:v h264_videotoolbox \
> > >            -b:v 2000k \
> > >            -c:a copy \
> > >            -y progressive.ts
> > >
> > > (note that uploading AVFrame into CVPixelBuffer via hwupload
> > >  requires 504c60660d3194758823ddd45ceddb86e35d806f)
> > >
> > > this work is sponsored by Fancy Bits LLC
> > >
> > > Reviewed-by: Ridley Combs <rcombs@rcombs.me>
> > > Signed-off-by: Aman Karmani <aman@tmm1.net>
> > > ---
> > >  configure                                     |   1 +
> > >  libavfilter/Makefile                          |   4 +
> > >  libavfilter/allfilters.c                      |   1 +
> > >  libavfilter/metal/vf_yadif_videotoolbox.metal | 269 ++++++++++++
> > >  libavfilter/vf_yadif_videotoolbox.m           | 406
> > > ++++++++++++++++++ 5 files changed, 681 insertions(+)
> > >  create mode 100644 libavfilter/metal/vf_yadif_videotoolbox.metal
> > >  create mode 100644 libavfilter/vf_yadif_videotoolbox.m
> > >
> > > diff --git a/configure b/configure
> > > index 32a39f5f5b..d8b07c8e00 100755
> > > --- a/configure
> > > +++ b/configure
> > > @@ -3748,6 +3748,7 @@ vpp_qsv_filter_select="qsvvpp"
> > >  xfade_opencl_filter_deps="opencl"
> > >  yadif_cuda_filter_deps="ffnvcodec"
> > >  yadif_cuda_filter_deps_any="cuda_nvcc cuda_llvm"
> > > +yadif_videotoolbox_filter_deps="metal corevideo videotoolbox"
> > >
> > >  # examples
> > >  avio_list_dir_deps="avformat avutil"
> > > diff --git a/libavfilter/Makefile b/libavfilter/Makefile
> > > index 2fe495df28..9a061ba3c8 100644
> > > --- a/libavfilter/Makefile
> > > +++ b/libavfilter/Makefile
> > > @@ -519,6 +519,10 @@ OBJS-$(CONFIG_XSTACK_FILTER)                 +=
> > > vf_stack.o framesync.o OBJS-$(CONFIG_YADIF_FILTER)
> > > += vf_yadif.o yadif_common.o OBJS-$(CONFIG_YADIF_CUDA_FILTER)
> > >     += vf_yadif_cuda.o vf_yadif_cuda.ptx.o \ yadif_common.o
> > > cuda/load_helper.o +OBJS-$(CONFIG_YADIF_VIDEOTOOLBOX_FILTER)     +=
> > > vf_yadif_videotoolbox.o \
> > > +
> > > metal/vf_yadif_videotoolbox.metallib.o \
> > > +                                                metal/utils.o \
> > > +                                                yadif_common.o
> > >  OBJS-$(CONFIG_YAEPBLUR_FILTER)               += vf_yaepblur.o
> > >  OBJS-$(CONFIG_ZMQ_FILTER)                    += f_zmq.o
> > >  OBJS-$(CONFIG_ZOOMPAN_FILTER)                += vf_zoompan.o
> > > diff --git a/libavfilter/allfilters.c b/libavfilter/allfilters.c
> > > index ec57a2c49c..26f1c73505 100644
> > > --- a/libavfilter/allfilters.c
> > > +++ b/libavfilter/allfilters.c
> > > @@ -496,6 +496,7 @@ extern const AVFilter ff_vf_xmedian;
> > >  extern const AVFilter ff_vf_xstack;
> > >  extern const AVFilter ff_vf_yadif;
> > >  extern const AVFilter ff_vf_yadif_cuda;
> > > +extern const AVFilter ff_vf_yadif_videotoolbox;
> > >  extern const AVFilter ff_vf_yaepblur;
> > >  extern const AVFilter ff_vf_zmq;
> > >  extern const AVFilter ff_vf_zoompan;
> > > diff --git a/libavfilter/metal/vf_yadif_videotoolbox.metal
> > > b/libavfilter/metal/vf_yadif_videotoolbox.metal new file mode 100644
> > > index 0000000000..50783f2ffe
> > > --- /dev/null
> > > +++ b/libavfilter/metal/vf_yadif_videotoolbox.metal
> > > @@ -0,0 +1,269 @@
> > > +/*
> > > + * Copyright (C) 2018 Philip Langdale <philipl@overt.org>
> > > + *               2020 Aman Karmani <aman@tmm1.net>
> > > + *               2020 Stefan Dyulgerov <stefan.dyulgerov@gmail.com>
> > > + *
> > > + * 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 FFmpeg; if not, write to the Free Software
> > > + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
> > > 02110-1301 USA
> > > + */
> > > +
> > > +#include <metal_stdlib>
> > > +#include <metal_integer>
> > > +#include <metal_texture>
> > > +
> > > +using namespace metal;
> > > +
> > > +/*
> > > + * Parameters
> > > + */
> > > +
> > > +struct deintParams {
> > > +    uint channels;
> > > +    uint parity;
> > > +    uint tff;
> > > +    bool is_second_field;
> > > +    bool skip_spatial_check;
> > > +    int field_mode;
> > > +};
> > > +
> > > +/*
> > > + * Texture access helpers
> > > + */
> > > +
> > > +#define accesstype access::sample
> > > +const sampler s(coord::pixel);
> > > +
> > > +template <typename T>
> > > +T tex2D(texture2d<float, access::sample> tex, uint x, uint y)
> > > +{
> > > +    return tex.sample(s, float2(x, y)).x;
> > > +}
> > > +
> > > +template <>
> > > +float2 tex2D<float2>(texture2d<float, access::sample> tex, uint x,
> > > uint y) +{
> > > +    return tex.sample(s, float2(x, y)).xy;
> > > +}
> > > +
> > > +template <typename T>
> > > +T tex2D(texture2d<float, access::read> tex, uint x, uint y)
> > > +{
> > > +    return tex.read(uint2(x, y)).x;
> > > +}
> > > +
> > > +template <>
> > > +float2 tex2D<float2>(texture2d<float, access::read> tex, uint x,
> > > uint y) +{
> > > +    return tex.read(uint2(x, y)).xy;
> > > +}
> > > +
> > > +/*
> > > + * YADIF helpers
> > > + */
> > > +
> > > +template<typename T>
> > > +T spatial_predictor(T a, T b, T c, T d, T e, T f, T g,
> > > +                    T h, T i, T j, T k, T l, T m, T n)
> > > +{
> > > +    T spatial_pred = (d + k)/2;
> > > +    T spatial_score = abs(c - j) + abs(d - k) + abs(e - l);
> > > +
> > > +    T score = abs(b - k) + abs(c - l) + abs(d - m);
> > > +    if (score < spatial_score) {
> > > +        spatial_pred = (c + l)/2;
> > > +        spatial_score = score;
> > > +        score = abs(a - l) + abs(b - m) + abs(c - n);
> > > +        if (score < spatial_score) {
> > > +            spatial_pred = (b + m)/2;
> > > +            spatial_score = score;
> > > +        }
> > > +    }
> > > +    score = abs(d - i) + abs(e - j) + abs(f - k);
> > > +    if (score < spatial_score) {
> > > +        spatial_pred = (e + j)/2;
> > > +        spatial_score = score;
> > > +        score = abs(e - h) + abs(f - i) + abs(g - j);
> > > +        if (score < spatial_score) {
> > > +            spatial_pred = (f + i)/2;
> > > +            spatial_score = score;
> > > +        }
> > > +    }
> > > +    return spatial_pred;
> > > +}
> > > +
> > > +template<typename T>
> > > +T temporal_predictor(T A, T B, T C, T D, T E, T F,
> > > +                     T G, T H, T I, T J, T K, T L,
> > > +                     T spatial_pred, bool skip_check)
> > > +{
> > > +    T p0 = (C + H) / 2;
> > > +    T p1 = F;
> > > +    T p2 = (D + I) / 2;
> > > +    T p3 = G;
> > > +    T p4 = (E + J) / 2;
> > > +
> > > +    T tdiff0 = abs(D - I);
> > > +    T tdiff1 = (abs(A - F) + abs(B - G)) / 2;
> > > +    T tdiff2 = (abs(K - F) + abs(G - L)) / 2;
> > > +
> > > +    T diff = max3(tdiff0, tdiff1, tdiff2);
> > > +
> > > +    if (!skip_check) {
> > > +        T maxi = max3(p2 - p3, p2 - p1, min(p0 - p1, p4 - p3));
> > > +        T mini = min3(p2 - p3, p2 - p1, max(p0 - p1, p4 - p3));
> > > +        diff = max3(diff, mini, -maxi);
> > > +    }
> > > +
> > > +    return clamp(spatial_pred, p2 - diff, p2 + diff);
> > > +}
> > > +
> > > +#define T float2
> > > +template <>
> > > +T spatial_predictor<T>(T a, T b, T c, T d, T e, T f, T g,
> > > +                       T h, T i, T j, T k, T l, T m, T n)
> > > +{
> > > +    return T(
> > > +        spatial_predictor(a.x, b.x, c.x, d.x, e.x, f.x, g.x,
> > > +                          h.x, i.x, j.x, k.x, l.x, m.x, n.x),
> > > +        spatial_predictor(a.y, b.y, c.y, d.y, e.y, f.y, g.y,
> > > +                          h.y, i.y, j.y, k.y, l.y, m.y, n.y)
> > > +    );
> > > +}
> > > +
> > > +template <>
> > > +T temporal_predictor<T>(T A, T B, T C, T D, T E, T F,
> > > +                        T G, T H, T I, T J, T K, T L,
> > > +                        T spatial_pred, bool skip_check)
> > > +{
> > > +    return T(
> > > +        temporal_predictor(A.x, B.x, C.x, D.x, E.x, F.x,
> > > +                           G.x, H.x, I.x, J.x, K.x, L.x,
> > > +                           spatial_pred.x, skip_check),
> > > +        temporal_predictor(A.y, B.y, C.y, D.y, E.y, F.y,
> > > +                           G.y, H.y, I.y, J.y, K.y, L.y,
> > > +                           spatial_pred.y, skip_check)
> > > +    );
> > > +}
> > > +#undef T
> > > +
> > > +/*
> > > + * YADIF compute
> > > + */
> > > +
> > > +template <typename T>
> > > +T yadif_compute_spatial(
> > > +    texture2d<float, accesstype> cur,
> > > +    uint2 pos)
> > > +{
> > > +    // Calculate spatial prediction
> > > +    T a = tex2D<T>(cur, pos.x - 3, pos.y - 1);
> > > +    T b = tex2D<T>(cur, pos.x - 2, pos.y - 1);
> > > +    T c = tex2D<T>(cur, pos.x - 1, pos.y - 1);
> > > +    T d = tex2D<T>(cur, pos.x - 0, pos.y - 1);
> > > +    T e = tex2D<T>(cur, pos.x + 1, pos.y - 1);
> > > +    T f = tex2D<T>(cur, pos.x + 2, pos.y - 1);
> > > +    T g = tex2D<T>(cur, pos.x + 3, pos.y - 1);
> > > +
> > > +    T h = tex2D<T>(cur, pos.x - 3, pos.y + 1);
> > > +    T i = tex2D<T>(cur, pos.x - 2, pos.y + 1);
> > > +    T j = tex2D<T>(cur, pos.x - 1, pos.y + 1);
> > > +    T k = tex2D<T>(cur, pos.x - 0, pos.y + 1);
> > > +    T l = tex2D<T>(cur, pos.x + 1, pos.y + 1);
> > > +    T m = tex2D<T>(cur, pos.x + 2, pos.y + 1);
> > > +    T n = tex2D<T>(cur, pos.x + 3, pos.y + 1);
> > > +
> > > +    return spatial_predictor(a, b, c, d, e, f, g,
> > > +                             h, i, j, k, l, m, n);
> > > +}
> > > +
> > > +template <typename T>
> > > +T yadif_compute_temporal(
> > > +    texture2d<float, accesstype> cur,
> > > +    texture2d<float, accesstype> prev2,
> > > +    texture2d<float, accesstype> prev1,
> > > +    texture2d<float, accesstype> next1,
> > > +    texture2d<float, accesstype> next2,
> > > +    T spatial_pred,
> > > +    bool skip_spatial_check,
> > > +    uint2 pos)
> > > +{
> > > +    // Calculate temporal prediction
> > > +    T A = tex2D<T>(prev2, pos.x, pos.y - 1);
> > > +    T B = tex2D<T>(prev2, pos.x, pos.y + 1);
> > > +    T C = tex2D<T>(prev1, pos.x, pos.y - 2);
> > > +    T D = tex2D<T>(prev1, pos.x, pos.y + 0);
> > > +    T E = tex2D<T>(prev1, pos.x, pos.y + 2);
> > > +    T F = tex2D<T>(cur,   pos.x, pos.y - 1);
> > > +    T G = tex2D<T>(cur,   pos.x, pos.y + 1);
> > > +    T H = tex2D<T>(next1, pos.x, pos.y - 2);
> > > +    T I = tex2D<T>(next1, pos.x, pos.y + 0);
> > > +    T J = tex2D<T>(next1, pos.x, pos.y + 2);
> > > +    T K = tex2D<T>(next2, pos.x, pos.y - 1);
> > > +    T L = tex2D<T>(next2, pos.x, pos.y + 1);
> > > +
> > > +    return temporal_predictor(A, B, C, D, E, F, G, H, I, J, K, L,
> > > +                              spatial_pred, skip_spatial_check);
> > > +}
> > > +
> > > +template <typename T>
> > > +T yadif(
> > > +    texture2d<float, access::write> dst,
> > > +    texture2d<float, accesstype> prev,
> > > +    texture2d<float, accesstype> cur,
> > > +    texture2d<float, accesstype> next,
> > > +    constant deintParams& params,
> > > +    uint2 pos)
> > > +{
> > > +    T spatial_pred = yadif_compute_spatial<T>(cur, pos);
> > > +
> > > +    if (params.is_second_field) {
> > > +        return yadif_compute_temporal(cur, prev, cur, next, next,
> > > spatial_pred, params.skip_spatial_check, pos);
> > > +    } else {
> > > +        return yadif_compute_temporal(cur, prev, prev, cur, next,
> > > spatial_pred, params.skip_spatial_check, pos);
> > > +    }
> > > +}
> > > +
> > > +/*
> > > + * Kernel dispatch
> > > + */
> > > +
> > > +kernel void deint(
> > > +    texture2d<float, access::write> dst [[texture(0)]],
> > > +    texture2d<float, accesstype> prev [[texture(1)]],
> > > +    texture2d<float, accesstype> cur  [[texture(2)]],
> > > +    texture2d<float, accesstype> next [[texture(3)]],
> > > +    constant deintParams& params [[buffer(4)]],
> > > +    uint2 pos [[thread_position_in_grid]])
> > > +{
> > > +    if ((pos.x >= dst.get_width()) ||
> > > +        (pos.y >= dst.get_height())) {
> > > +        return;
> > > +    }
> > > +
> > > +    // Don't modify the primary field
> > > +    if (pos.y % 2 == params.parity) {
> > > +        float4 in = cur.read(pos);
> > > +        dst.write(in, pos);
> > > +        return;
> > > +    }
> > > +
> > > +    float2 pred;
> > > +    if (params.channels == 1)
> > > +        pred = float2(yadif<float>(dst, prev, cur, next, params,
> > > pos));
> > > +    else
> > > +        pred = yadif<float2>(dst, prev, cur, next, params, pos);
> > > +    dst.write(pred.xyyy, pos);
> > > +}
> > > diff --git a/libavfilter/vf_yadif_videotoolbox.m
> > > b/libavfilter/vf_yadif_videotoolbox.m new file mode 100644
> > > index 0000000000..af83a73e89
> > > --- /dev/null
> > > +++ b/libavfilter/vf_yadif_videotoolbox.m
> > > @@ -0,0 +1,406 @@
> > > +/*
> > > + * Copyright (C) 2018 Philip Langdale <philipl@overt.org>
> > > + *               2020 Aman Karmani <aman@tmm1.net>
> > > + *
> > > + * 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 FFmpeg; if not, write to the Free Software
> > > + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
> > > 02110-1301 USA
> > > + */
> > > +
> > > +#include "internal.h"
> > > +#include "yadif.h"
> > > +#include <libavutil/avassert.h>
> > > +#include <libavutil/hwcontext.h>
> > > +#include <libavutil/objc.h>
> > > +#include <libavfilter/metal/utils.h>
> > > +
> > > +extern char ff_vf_yadif_videotoolbox_metallib_data[];
> > > +extern unsigned int ff_vf_yadif_videotoolbox_metallib_len;
> > > +
> > > +typedef struct YADIFVTContext {
> > > +    YADIFContext yadif;
> > > +
> > > +    AVBufferRef       *device_ref;
> > > +    AVBufferRef       *input_frames_ref;
> > > +    AVHWFramesContext *input_frames;
> > > +
> > > +    id<MTLDevice> mtlDevice;
> > > +    id<MTLLibrary> mtlLibrary;
> > > +    id<MTLCommandQueue> mtlQueue;
> > > +    id<MTLComputePipelineState> mtlPipeline;
> > > +    id<MTLFunction> mtlFunction;
> > > +    id<MTLBuffer> mtlParamsBuffer;
> > > +
> > > +    CVMetalTextureCacheRef textureCache;
> > > +} YADIFVTContext;
> > > +
> > > +struct mtlYadifParams {
> > > +    uint channels;
> > > +    uint parity;
> > > +    uint tff;
> > > +    bool is_second_field;
> > > +    bool skip_spatial_check;
> > > +    int field_mode;
> > > +};
> > > +
> > > +static void call_kernel(AVFilterContext *ctx,
> > > +                        id<MTLTexture> dst,
> > > +                        id<MTLTexture> prev,
> > > +                        id<MTLTexture> cur,
> > > +                        id<MTLTexture> next,
> > > +                        int channels,
> > > +                        int parity,
> > > +                        int tff)
> > > +{
> > > +    YADIFVTContext *s = ctx->priv;
> > > +    id<MTLCommandBuffer> buffer = s->mtlQueue.commandBuffer;
> > > +    id<MTLComputeCommandEncoder> encoder =
> > > buffer.computeCommandEncoder;
> > > +    struct mtlYadifParams *params = (struct mtlYadifParams
> > > *)s->mtlParamsBuffer.contents;
> > > +    *params = (struct mtlYadifParams){
> > > +        .channels = channels,
> > > +        .parity = parity,
> > > +        .tff = tff,
> > > +        .is_second_field = !(parity ^ tff),
> > > +        .skip_spatial_check = s->yadif.mode&2,
> > > +        .field_mode = s->yadif.current_field
> > > +    };
> > > +
> > > +    [encoder setTexture:dst  atIndex:0];
> > > +    [encoder setTexture:prev atIndex:1];
> > > +    [encoder setTexture:cur  atIndex:2];
> > > +    [encoder setTexture:next atIndex:3];
> > > +    [encoder setBuffer:s->mtlParamsBuffer offset:0 atIndex:4];
> > > +    ff_metal_compute_encoder_dispatch(s->mtlDevice, s->mtlPipeline,
> > > encoder, dst.width, dst.height);
> > > +    [encoder endEncoding];
> > > +
> > > +    [buffer commit];
> > > +    [buffer waitUntilCompleted];
> > > +
> > > +    ff_objc_release(&encoder);
> > > +    ff_objc_release(&buffer);
> > > +}
> > > +
> > > +static void filter(AVFilterContext *ctx, AVFrame *dst,
> > > +                   int parity, int tff)
> > > +{
> > > +    YADIFVTContext *s = ctx->priv;
> > > +    YADIFContext *y = &s->yadif;
> > > +    int i;
> > > +
> > > +    for (i = 0; i < y->csp->nb_components; i++) {
> > > +        int pixel_size, channels;
> > > +        const AVComponentDescriptor *comp = &y->csp->comp[i];
> > > +        CVMetalTextureRef prev, cur, next, dest;
> > > +        id<MTLTexture> tex_prev, tex_cur, tex_next, tex_dest;
> > > +        MTLPixelFormat format;
> > > +
> > > +        if (comp->plane < i) {
> > > +            // We process planes as a whole, so don't reprocess
> > > +            // them for additional components
> > > +            continue;
> > > +        }
> > > +
> > > +        pixel_size = (comp->depth + comp->shift) / 8;
> > > +        channels = comp->step / pixel_size;
> > > +        if (pixel_size > 2 || channels > 2) {
> > > +            av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format:
> > > %s\n", y->csp->name);
> > > +            goto exit;
> > > +        }
> > > +        switch (pixel_size) {
> > > +        case 1:
> > > +            format = channels == 1 ? MTLPixelFormatR8Unorm :
> > > MTLPixelFormatRG8Unorm;
> > > +            break;
> > > +        case 2:
> > > +            format = channels == 1 ? MTLPixelFormatR16Unorm :
> > > MTLPixelFormatRG16Unorm;
> > > +            break;
> > > +        default:
> > > +            av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format:
> > > %s\n", y->csp->name);
> > > +            goto exit;
> > > +        }
> > > +        av_log(ctx, AV_LOG_TRACE,
> > > +               "Deinterlacing plane %d: pixel_size: %d channels:
> > > %d\n",
> > > +               comp->plane, pixel_size, channels);
> > > +
> > > +        prev = ff_metal_texture_from_pixbuf(ctx, s->textureCache,
> > > (CVPixelBufferRef)y->prev->data[3], i, format);
> > > +        cur  = ff_metal_texture_from_pixbuf(ctx, s->textureCache,
> > > (CVPixelBufferRef)y->cur->data[3], i, format);
> > > +        next = ff_metal_texture_from_pixbuf(ctx, s->textureCache,
> > > (CVPixelBufferRef)y->next->data[3], i, format);
> > > +        dest = ff_metal_texture_from_pixbuf(ctx, s->textureCache,
> > > (CVPixelBufferRef)dst->data[3], i, format); +
> > > +        tex_prev = CVMetalTextureGetTexture(prev);
> > > +        tex_cur  = CVMetalTextureGetTexture(cur);
> > > +        tex_next = CVMetalTextureGetTexture(next);
> > > +        tex_dest = CVMetalTextureGetTexture(dest);
> > > +
> > > +        call_kernel(ctx, tex_dest, tex_prev, tex_cur, tex_next,
> > > +                         channels, parity, tff);
> > > +
> > > +        CFRelease(prev);
> > > +        CFRelease(cur);
> > > +        CFRelease(next);
> > > +        CFRelease(dest);
> > > +    }
> > > +
> > > +    CVBufferPropagateAttachments((CVPixelBufferRef)y->cur->data[3],
> > > (CVPixelBufferRef)dst->data[3]); +
> > > +    if (y->current_field == YADIF_FIELD_END) {
> > > +        y->current_field = YADIF_FIELD_NORMAL;
> > > +    }
> > > +
> > > +exit:
> > > +    return;
> > > +}
> > > +
> > > +static av_cold void yadif_videotoolbox_uninit(AVFilterContext *ctx)
> > > +{
> > > +    YADIFVTContext *s = ctx->priv;
> > > +    YADIFContext *y = &s->yadif;
> > > +
> > > +    av_frame_free(&y->prev);
> > > +    av_frame_free(&y->cur);
> > > +    av_frame_free(&y->next);
> > > +
> > > +    av_buffer_unref(&s->device_ref);
> > > +    av_buffer_unref(&s->input_frames_ref);
> > > +    s->input_frames = NULL;
> > > +
> > > +    ff_objc_release(&s->mtlParamsBuffer);
> > > +    ff_objc_release(&s->mtlFunction);
> > > +    ff_objc_release(&s->mtlPipeline);
> > > +    ff_objc_release(&s->mtlQueue);
> > > +    ff_objc_release(&s->mtlLibrary);
> > > +    ff_objc_release(&s->mtlDevice);
> > > +
> > > +    if (s->textureCache) {
> > > +        CFRelease(s->textureCache);
> > > +        s->textureCache = NULL;
> > > +    }
> > > +}
> > > +
> > > +static av_cold int yadif_videotoolbox_init(AVFilterContext *ctx)
> > > +{
> > > +    YADIFVTContext *s = ctx->priv;
> > > +    NSError *err = nil;
> > > +    CVReturn ret;
> > > +
> > > +    s->mtlDevice = MTLCreateSystemDefaultDevice();
> > > +    if (!s->mtlDevice) {
> > > +        av_log(ctx, AV_LOG_ERROR, "Unable to find Metal device\n");
> > > +        goto fail;
> > > +    }
> > > +
> > > +    av_log(ctx, AV_LOG_INFO, "Using Metal device: %s\n",
> > > s->mtlDevice.name.UTF8String); +
> > > +    dispatch_data_t libData = dispatch_data_create(
> > > +        ff_vf_yadif_videotoolbox_metallib_data,
> > > +        ff_vf_yadif_videotoolbox_metallib_len,
> > > +        nil,
> > > +        nil);
> > > +    s->mtlLibrary = [s->mtlDevice newLibraryWithData:libData
> > > error:&err];
> > > +    dispatch_release(libData);
> > > +    libData = nil;
> > > +    if (err) {
> > > +        av_log(ctx, AV_LOG_ERROR, "Failed to load Metal library:
> > > %s\n", err.description.UTF8String);
> > > +        goto fail;
> > > +    }
> > > +
> > > +    s->mtlFunction = [s->mtlLibrary newFunctionWithName:@"deint"];
> > > +    if (!s->mtlFunction) {
> > > +        av_log(ctx, AV_LOG_ERROR, "Failed to create Metal
> > > function!\n");
> > > +        goto fail;
> > > +    }
> > > +
> > > +    s->mtlQueue = s->mtlDevice.newCommandQueue;
> > > +    if (!s->mtlQueue) {
> > > +        av_log(ctx, AV_LOG_ERROR, "Failed to create Metal command
> > > queue!\n");
> > > +        goto fail;
> > > +    }
> > > +
> > > +    s->mtlPipeline = [s->mtlDevice
> > > +        newComputePipelineStateWithFunction:s->mtlFunction
> > > +        error:&err];
> > > +    if (err) {
> > > +        av_log(ctx, AV_LOG_ERROR, "Failed to create Metal compute
> > > pipeline: %s\n", err.description.UTF8String);
> > > +        goto fail;
> > > +    }
> > > +
> > > +    s->mtlParamsBuffer = [s->mtlDevice
> > > +        newBufferWithLength:sizeof(struct mtlYadifParams)
> > > +        options:MTLResourceStorageModeShared];
> > > +    if (!s->mtlParamsBuffer) {
> > > +        av_log(ctx, AV_LOG_ERROR, "Failed to create Metal buffer for
> > > parameters\n");
> > > +        goto fail;
> > > +    }
> > > +
> > > +    ret = CVMetalTextureCacheCreate(
> > > +        NULL,
> > > +        NULL,
> > > +        s->mtlDevice,
> > > +        NULL,
> > > +        &s->textureCache
> > > +    );
> > > +    if (ret != kCVReturnSuccess) {
> > > +        av_log(ctx, AV_LOG_ERROR, "Failed to create
> > > CVMetalTextureCache: %d\n", ret);
> > > +        goto fail;
> > > +    }
> > > +
> > > +    return 0;
> > > +fail:
> > > +    yadif_videotoolbox_uninit(ctx);
> > > +    return AVERROR_EXTERNAL;
> > > +}
> > > +
> > > +static int config_input(AVFilterLink *inlink)
> > > +{
> > > +    AVFilterContext *ctx = inlink->dst;
> > > +    YADIFVTContext *s = ctx->priv;
> > > +
> > > +    if (!inlink->hw_frames_ctx) {
> > > +        av_log(ctx, AV_LOG_ERROR, "A hardware frames reference is "
> > > +               "required to associate the processing device.\n");
> > > +        return AVERROR(EINVAL);
> > > +    }
> > > +
> > > +    s->input_frames_ref = av_buffer_ref(inlink->hw_frames_ctx);
> > > +    if (!s->input_frames_ref) {
> > > +        av_log(ctx, AV_LOG_ERROR, "A input frames reference create "
> > > +               "failed.\n");
> > > +        return AVERROR(ENOMEM);
> > > +    }
> > > +    s->input_frames = (AVHWFramesContext*)s->input_frames_ref->data;
> > > +
> > > +    return 0;
> > > +}
> > > +
> > > +static int config_output(AVFilterLink *link)
> > > +{
> > > +    AVHWFramesContext *output_frames;
> > > +    AVFilterContext *ctx = link->src;
> > > +    YADIFVTContext *s = ctx->priv;
> > > +    YADIFContext *y = &s->yadif;
> > > +    int ret = 0;
> > > +
> > > +    av_assert0(s->input_frames);
> > > +    s->device_ref = av_buffer_ref(s->input_frames->device_ref);
> > > +    if (!s->device_ref) {
> > > +        av_log(ctx, AV_LOG_ERROR, "A device reference create "
> > > +               "failed.\n");
> > > +        return AVERROR(ENOMEM);
> > > +    }
> > > +
> > > +    link->hw_frames_ctx = av_hwframe_ctx_alloc(s->device_ref);
> > > +    if (!link->hw_frames_ctx) {
> > > +        av_log(ctx, AV_LOG_ERROR, "Failed to create HW frame context
> > > "
> > > +               "for output.\n");
> > > +        ret = AVERROR(ENOMEM);
> > > +        goto exit;
> > > +    }
> > > +
> > > +    output_frames = (AVHWFramesContext*)link->hw_frames_ctx->data;
> > > +
> > > +    output_frames->format    = AV_PIX_FMT_VIDEOTOOLBOX;
> > > +    output_frames->sw_format = s->input_frames->sw_format;
> > > +    output_frames->width     = ctx->inputs[0]->w;
> > > +    output_frames->height    = ctx->inputs[0]->h;
> > > +
> > > +    ret = ff_filter_init_hw_frames(ctx, link, 10);
> > > +    if (ret < 0)
> > > +        goto exit;
> > > +
> > > +    ret = av_hwframe_ctx_init(link->hw_frames_ctx);
> > > +    if (ret < 0) {
> > > +        av_log(ctx, AV_LOG_ERROR, "Failed to initialise VideoToolbox
> > > frame "
> > > +               "context for output: %d\n", ret);
> > > +        goto exit;
> > > +    }
> > > +
> > > +    link->time_base.num = ctx->inputs[0]->time_base.num;
> > > +    link->time_base.den = ctx->inputs[0]->time_base.den * 2;
> > > +    link->w             = ctx->inputs[0]->w;
> > > +    link->h             = ctx->inputs[0]->h;
> > > +
> > > +    if(y->mode & 1)
> > > +        link->frame_rate = av_mul_q(ctx->inputs[0]->frame_rate,
> > > +                                    (AVRational){2, 1});
> > > +
> > > +    if (link->w < 3 || link->h < 3) {
> > > +        av_log(ctx, AV_LOG_ERROR, "Video of less than 3 columns or
> > > lines is not supported\n");
> > > +        ret = AVERROR(EINVAL);
> > > +        goto exit;
> > > +    }
> > > +
> > > +    y->csp = av_pix_fmt_desc_get(output_frames->sw_format);
> > > +    y->filter = filter;
> > > +
> > > +exit:
> > > +    return ret;
> > > +}
> > > +
> > > +#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
> > > +#define CONST(name, help, val, unit) { name, help, 0,
> > > AV_OPT_TYPE_CONST, {.i64=val}, INT_MIN, INT_MAX, FLAGS, unit } +
> > > +static const AVOption yadif_videotoolbox_options[] = {
> > > +    #define OFFSET(x) offsetof(YADIFContext, x)
> > > +    { "mode",   "specify the interlacing mode", OFFSET(mode),
> > > AV_OPT_TYPE_INT, {.i64=YADIF_MODE_SEND_FRAME}, 0, 3, FLAGS, "mode"},
> > > +    CONST("send_frame",           "send one frame for each frame",
> > >                                   YADIF_MODE_SEND_FRAME,
> > > "mode"),
> > > +    CONST("send_field",           "send one frame for each field",
> > >                                   YADIF_MODE_SEND_FIELD,
> > > "mode"),
> > > +    CONST("send_frame_nospatial", "send one frame for each frame,
> > > but skip spatial interlacing check", YADIF_MODE_SEND_FRAME_NOSPATIAL,
> > > "mode"),
> > > +    CONST("send_field_nospatial", "send one frame for each field,
> > > but skip spatial interlacing check", YADIF_MODE_SEND_FIELD_NOSPATIAL,
> > > "mode"), +
> > > +    { "parity", "specify the assumed picture field parity",
> > > OFFSET(parity), AV_OPT_TYPE_INT, {.i64=YADIF_PARITY_AUTO}, -1, 1,
> > > FLAGS, "parity" },
> > > +    CONST("tff",  "assume top field first",    YADIF_PARITY_TFF,
> > > "parity"),
> > > +    CONST("bff",  "assume bottom field first", YADIF_PARITY_BFF,
> > > "parity"),
> > > +    CONST("auto", "auto detect parity",        YADIF_PARITY_AUTO,
> > > "parity"), +
> > > +    { "deint", "specify which frames to deinterlace", OFFSET(deint),
> > > AV_OPT_TYPE_INT, {.i64=YADIF_DEINT_ALL}, 0, 1, FLAGS, "deint" },
> > > +    CONST("all",        "deinterlace all frames",
> > >    YADIF_DEINT_ALL,        "deint"),
> > > +    CONST("interlaced", "only deinterlace frames marked as
> > > interlaced", YADIF_DEINT_INTERLACED, "deint"),
> > > +    #undef OFFSET
> > > +
> > > +    { NULL }
> > > +};
> > > +
> > > +AVFILTER_DEFINE_CLASS(yadif_videotoolbox);
> > > +
> > > +static const AVFilterPad yadif_videotoolbox_inputs[] = {
> > > +    {
> > > +        .name          = "default",
> > > +        .type          = AVMEDIA_TYPE_VIDEO,
> > > +        .filter_frame  = ff_yadif_filter_frame,
> > > +        .config_props  = config_input,
> > > +    },
> > > +};
> > > +
> > > +static const AVFilterPad yadif_videotoolbox_outputs[] = {
> > > +    {
> > > +        .name          = "default",
> > > +        .type          = AVMEDIA_TYPE_VIDEO,
> > > +        .request_frame = ff_yadif_request_frame,
> > > +        .config_props  = config_output,
> > > +    },
> > > +};
> > > +
> > > +AVFilter ff_vf_yadif_videotoolbox = {
> > > +    .name           = "yadif_videotoolbox",
> > > +    .description    = NULL_IF_CONFIG_SMALL("YADIF for VideoToolbox
> > > frames using Metal compute"),
> > > +    .priv_size      = sizeof(YADIFVTContext),
> > > +    .priv_class     = &yadif_videotoolbox_class,
> > > +    .init           = yadif_videotoolbox_init,
> > > +    .uninit         = yadif_videotoolbox_uninit,
> > > +    FILTER_SINGLE_PIXFMT(AV_PIX_FMT_VIDEOTOOLBOX),
> > > +    FILTER_INPUTS(yadif_videotoolbox_inputs),
> > > +    FILTER_OUTPUTS(yadif_videotoolbox_outputs),
> > > +    .flags          = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
> > > +    .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
> > > +};
> >
> > LGTM for the general part. I'll take your work that the metal specific
> > parts work as intended.
> >
>
> Patchset applied. Thanks to everyone who helped review on and off-list.
>
>
>
It appears to break the build for me:

```
MAN doc/libavfilter.3
GEN libswresample/libswresample.ver
LD libswscale/libswscale.6.dylib
LD libpostproc/libpostproc.56.dylib
LD libswresample/libswresample.4.dylib
STRIP libavcodec/x86/vp9itxfm.o
GEN libavcodec/libavcodec.ver
LD libavcodec/libavcodec.59.dylib
ld: warning: could not create compact unwind for _ff_cfhd_init_vlcs: stack
subq instruction is too different from dwarf stack size
ld: warning: could not create compact unwind for _ff_rl_init_vlc: stack
subq instruction is too different from dwarf stack size
LD libavformat/libavformat.59.dylib
LD libavfilter/libavfilter.8.dylib
clang: error: no such file or directory:
'libavfilter/metal/vf_yadif_videotoolbox.metallib.o'
make: *** [libavfilter/libavfilter.8.dylib] Error 1

real 3m22.511s
user 16m21.483s
sys 1m43.498s
```


I initially tried --disable-metal, but that didn't work:
```
Unknown option "--disable-metal".
See /Users/pavel/src/ffmpeg/configure --help for available options.

real 0m0.271s
user 0m0.164s
sys 0m0.105s
```

I was able to work-around the linker error with
--disable-filter=yadif_videotoolbox


Pavel.
_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".