[FFmpeg-devel] [PATCH v2 00/13] YUVJ removal

[FFmpeg-devel] [PATCH v2 00/13] YUVJ removal

[Niklas Haas]

Changes since v1:

- Remove unneeded patch (AVCodecContext.colorspace init)
- Merge auto-range conversion into auto-scale filter
- Replace vf_zscale by vf_colorspace in fftools
- Add some miscellaneous fixes for various FATE tests
- Clean up some additional vestigiaul YUVJ remnants


_______________________________________________
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 v2 01/13] avfilter/vf_scale: don't change range by default

[Niklas Haas]

From: Niklas Haas <git@haasn.dev>

If we don't convert the pixel format, then we shouldn't touch the pixel
range by default, either. Ensures full-range YUV input comes out as
full-range YUV output, unless we go through a pixel format conversion.

In theory, we may also want to extend this logic to YUV->YUV
conversions, but a few special cases (YUVJ, Gray, RGB) make this more
annoying than it needs to be, so I'll defer it to a future commit.
---
 libavfilter/vf_scale.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/libavfilter/vf_scale.c b/libavfilter/vf_scale.c
index b0221e8538..9bbf0f8ed5 100644
--- a/libavfilter/vf_scale.c
+++ b/libavfilter/vf_scale.c
@@ -863,6 +863,8 @@ scale:
             in_full  = (in_range == AVCOL_RANGE_JPEG);
         if (scale->out_range != AVCOL_RANGE_UNSPECIFIED)
             out_full = (scale->out_range == AVCOL_RANGE_JPEG);
+        else if (in->format == out->format)
+            out_full = in_full; /* preserve pixel range by default */
 
         sws_setColorspaceDetails(scale->sws, inv_table, in_full,
                                  table, out_full,
-- 
2.42.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 v2 02/13] avcodec: add extended AVCodec color metadata

[Niklas Haas]

From: Niklas Haas <git@haasn.dev>

This is motivated primarily by a desire for YUVJ removal, which will
require signalling the supported color ranges as part of the codec
capabilities. But since we're here anyway, we might as well add all of
the metadata, which I foresee seeing more use in the future (e.g.
automatic conversion from HDR to SDR when encoding to formats that don't
support AVCOL_TRC_SMPTE2084, ...)
---
 doc/APIchanges       | 4 ++++
 libavcodec/codec.h   | 7 +++++++
 libavcodec/version.h | 4 ++--
 3 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/doc/APIchanges b/doc/APIchanges
index 9b109e6fa7..f91e855e70 100644
--- a/doc/APIchanges
+++ b/doc/APIchanges
@@ -2,6 +2,10 @@ The last version increases of all libraries were on 2023-02-09
 
 API changes, most recent first:
 
+2023-10-xx - xxxxxxxxxx - lavc 60.23.100 - avcodec.h
+  Add AVCodec.csps, AVCodec.color_ranges, AVCodec.chroma_locs, AVCodec.primaries,
+  AVCodec.trcs.
+
 2023-10-06 - xxxxxxxxxx - lavc 60.30.101 - avcodec.h
   AVCodecContext.coded_side_data may now be used during decoding, to be set
   by user before calling avcodec_open2() for initialization.
diff --git a/libavcodec/codec.h b/libavcodec/codec.h
index 8034f1a53c..5bc8f21868 100644
--- a/libavcodec/codec.h
+++ b/libavcodec/codec.h
@@ -235,6 +235,13 @@ typedef struct AVCodec {
      * Array of supported channel layouts, terminated with a zeroed layout.
      */
     const AVChannelLayout *ch_layouts;
+
+    /* Extended colorspace support metadata */
+    const enum AVColorSpace *csps;                  ///< array of supported color spaces, or NULL if unknown, array is terminated by AVCOL_SPC_UNSPECIFIED
+    const enum AVColorRange *color_ranges;          ///< array of supported color ranges, or NULL if unknown, array is terminated by 0
+    const enum AVChromaLocation *chroma_locs;       ///< array of supported chroma locations, or NULL if unknown, array is terminated by 0
+    const enum AVColorPrimaries *primaries;         ///< array of supported color primaries, or NULL if unknown, array is terminated by 0
+    const enum AVColorTransferCharacteristic *trcs; ///< array of supported transfer characteristics, or NULL if known, array is terminated by 0
 } AVCodec;
 
 /**
diff --git a/libavcodec/version.h b/libavcodec/version.h
index 6b46100aae..497389d3f3 100644
--- a/libavcodec/version.h
+++ b/libavcodec/version.h
@@ -29,8 +29,8 @@
 
 #include "version_major.h"
 
-#define LIBAVCODEC_VERSION_MINOR  30
-#define LIBAVCODEC_VERSION_MICRO 102
+#define LIBAVCODEC_VERSION_MINOR  31
+#define LIBAVCODEC_VERSION_MICRO 100
 
 #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
                                                LIBAVCODEC_VERSION_MINOR, \
-- 
2.42.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 v2 02/13] avcodec: add extended AVCodec color metadata

[Andreas Rheinhardt]

Niklas Haas:
> From: Niklas Haas <git@haasn.dev>
> 
> This is motivated primarily by a desire for YUVJ removal, which will
> require signalling the supported color ranges as part of the codec
> capabilities. But since we're here anyway, we might as well add all of
> the metadata, which I foresee seeing more use in the future (e.g.
> automatic conversion from HDR to SDR when encoding to formats that don't
> support AVCOL_TRC_SMPTE2084, ...)
> ---
>  doc/APIchanges       | 4 ++++
>  libavcodec/codec.h   | 7 +++++++
>  libavcodec/version.h | 4 ++--
>  3 files changed, 13 insertions(+), 2 deletions(-)
> 
> diff --git a/doc/APIchanges b/doc/APIchanges
> index 9b109e6fa7..f91e855e70 100644
> --- a/doc/APIchanges
> +++ b/doc/APIchanges
> @@ -2,6 +2,10 @@ The last version increases of all libraries were on 2023-02-09
>  
>  API changes, most recent first:
>  
> +2023-10-xx - xxxxxxxxxx - lavc 60.23.100 - avcodec.h
> +  Add AVCodec.csps, AVCodec.color_ranges, AVCodec.chroma_locs, AVCodec.primaries,
> +  AVCodec.trcs.
> +
>  2023-10-06 - xxxxxxxxxx - lavc 60.30.101 - avcodec.h
>    AVCodecContext.coded_side_data may now be used during decoding, to be set
>    by user before calling avcodec_open2() for initialization.
> diff --git a/libavcodec/codec.h b/libavcodec/codec.h
> index 8034f1a53c..5bc8f21868 100644
> --- a/libavcodec/codec.h
> +++ b/libavcodec/codec.h
> @@ -235,6 +235,13 @@ typedef struct AVCodec {
>       * Array of supported channel layouts, terminated with a zeroed layout.
>       */
>      const AVChannelLayout *ch_layouts;
> +
> +    /* Extended colorspace support metadata */
> +    const enum AVColorSpace *csps;                  ///< array of supported color spaces, or NULL if unknown, array is terminated by AVCOL_SPC_UNSPECIFIED
> +    const enum AVColorRange *color_ranges;          ///< array of supported color ranges, or NULL if unknown, array is terminated by 0
> +    const enum AVChromaLocation *chroma_locs;       ///< array of supported chroma locations, or NULL if unknown, array is terminated by 0
> +    const enum AVColorPrimaries *primaries;         ///< array of supported color primaries, or NULL if unknown, array is terminated by 0
> +    const enum AVColorTransferCharacteristic *trcs; ///< array of supported transfer characteristics, or NULL if known, array is terminated by 0
>  } AVCodec;
>  

This design has several drawbacks:
1. It adds stuff that will only be set by a tiny minority of AVCodec's
to all of them.
2. It is based around the underlying assumption that the set of
permissible states (tupels) is a cartesian product of a set of color
spaces, a set of color ranges etc. This is wrong: E.g. VP9 disallows
limited-range RGB (it is syntactically impossible to set the color range
when using RGB color space).
3. I don't see how the MJPEG encoder behaviour where the valid formats
de facto depend upon strictness can be encoded in this way; isn't the
aim to get rid of the necessity of the workaround in ffmpeg cli?

1. and 2. suggests using some form of function that returns a list of
supported tupels; if said function uses an AVCodecContext* parameter,
said list can depend upon the state of the AVCodecContext given to it,
thereby solving 3. to the extent that one can get the supported
combinations given AVCodecContext options (but I do not see a good way
to signal which options modify the supported combinations).

- Andreas

_______________________________________________
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 v2 02/13] avcodec: add extended AVCodec color metadata

[Vittorio Giovara]

On Fri, Oct 13, 2023 at 1:09 PM Andreas Rheinhardt <
andreas.rheinhardt@outlook.com> wrote:

> 2. It is based around the underlying assumption that the set of
> permissible states (tupels) is a cartesian product of a set of color
> spaces, a set of color ranges etc. This is wrong: E.g. VP9 disallows
> limited-range RGB (it is syntactically impossible to set the color range
> when using RGB color space).


small note on VP9 and other color-constrained codecs, it's still always
possible to set these parameters via the container, i.e. through the mp4
color box.
-- 
Vittorio
_______________________________________________
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 v2 02/13] avcodec: add extended AVCodec color metadata

[Niklas Haas]

On Fri, 13 Oct 2023 19:10:33 +0200 Andreas Rheinhardt <andreas.rheinhardt@outlook.com> wrote:
> This design has several drawbacks:
> 1. It adds stuff that will only be set by a tiny minority of AVCodec's
> to all of them.
> 2. It is based around the underlying assumption that the set of
> permissible states (tupels) is a cartesian product of a set of color
> spaces, a set of color ranges etc. This is wrong: E.g. VP9 disallows
> limited-range RGB (it is syntactically impossible to set the color range
> when using RGB color space).
> 3. I don't see how the MJPEG encoder behaviour where the valid formats
> de facto depend upon strictness can be encoded in this way; isn't the
> aim to get rid of the necessity of the workaround in ffmpeg cli?
> 
> 1. and 2. suggests using some form of function that returns a list of
> supported tupels; if said function uses an AVCodecContext* parameter,
> said list can depend upon the state of the AVCodecContext given to it,
> thereby solving 3. to the extent that one can get the supported
> combinations given AVCodecContext options (but I do not see a good way
> to signal which options modify the supported combinations).

There are two other designs I can think of:

1. Enumerate all possible combinations as a list. To avoid combinatoric
   explosion, setting any field to 'UNSPECIFIED' implies no restriction
   on that field. So the default (no list) would be equivalent to a list
   with a single entry containing values of UNSPECIFIED for every entry.

2. Provide a single function which merely checks if a given combination
   is supported or not.

#2 would work for the short term but runs into the same risk of
exponential explosion if we need to start finding a common format
between different filters.

So maybe #1 is the correct approach here. It would also simplify
extending the filter API, as we would only need one set of list
managing/merging/compat testing boilerplate for all of the colorspace
metadata.

I will try implementing #1 on a separate branch.
_______________________________________________
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 v2 02/13] avcodec: add extended AVCodec color metadata

[Niklas Haas]

On Fri, 13 Oct 2023 19:10:33 +0200 Andreas Rheinhardt <andreas.rheinhardt@outlook.com> wrote:
> 2. It is based around the underlying assumption that the set of
> permissible states (tupels) is a cartesian product of a set of color
> spaces, a set of color ranges etc. This is wrong: E.g. VP9 disallows
> limited-range RGB (it is syntactically impossible to set the color range
> when using RGB color space).

Well, upon further consideration, I don't think this is enough to break
the cartesian approach, because RGB is always full range by convention.
Note how vf_scale, vf_zscale and vf_libplacebo all force the color range
for RGB inputs to full. So this is not an exception, rather it is the
rule. In other words, for RGB input, the colorspace and color_range
restrictions should simply be ignored, as they conceptually apply to YUV
formats only.

Note also that, thinking a little bit ahead, independent list would make
AVFilter negotiation *much* easier as we could just re-use
AVFilterFormats for each field without worry - whereas a "list of
tuples" approach requires introducing a new struct to group such
metadata, a new type of AVFilterFormats list + all supporting functions,
and a lot more boilerplate overall.

So we need to think very carefully if there actually are any
sufficiently strong motivating cases to introduce such heavy machinery.

> 3. I don't see how the MJPEG encoder behaviour where the valid formats
> de facto depend upon strictness can be encoded in this way; isn't the
> aim to get rid of the necessity of the workaround in ffmpeg cli?

Note that ffmpeg cli presently initializes the filter graph well before
the AVCodecContext is set up with options, let alone opened. (Presently,
the logic for overriding the pixfmt list directly looks up the "strict"
field in the options dict)

So that limits the design space somewhat for elegant solutions here.
Either we make the "return list of supported formats" callback in
AVCodec simply accept the strict_std_compliance setting directly, or we
extend the static list of colorspaces itself by an extra strictness
field. Probably the former is better than the latter of these two
approaches.
_______________________________________________
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 v2 02/13] avcodec: add extended AVCodec color metadata

[Anton Khirnov]

Quoting Niklas Haas (2023-10-14 13:46:34)
> > 3. I don't see how the MJPEG encoder behaviour where the valid formats
> > de facto depend upon strictness can be encoded in this way; isn't the
> > aim to get rid of the necessity of the workaround in ffmpeg cli?
> 
> Note that ffmpeg cli presently initializes the filter graph well before
> the AVCodecContext is set up with options, let alone opened. (Presently,
> the logic for overriding the pixfmt list directly looks up the "strict"
> field in the options dict)
> 
> So that limits the design space somewhat for elegant solutions here.
> Either we make the "return list of supported formats" callback in
> AVCodec simply accept the strict_std_compliance setting directly, or we
> extend the static list of colorspaces itself by an extra strictness
> field. Probably the former is better than the latter of these two
> approaches.

FWIW I find that behaviour to be a disgusting hack and the cleanest way
to address it would IMO be a separate mjpeg_experimental AVCodec
instance. That is assuming anyone actually needs this functionality.
Maybe we could also just drop it?

-- 
Anton Khirnov
_______________________________________________
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 v2 02/13] avcodec: add extended AVCodec color metadata

[Michael Niedermayer]

[-- Attachment #1.1: Type: text/plain, Size: 1777 bytes --]

On Fri, Oct 20, 2023 at 03:54:16PM +0200, Anton Khirnov wrote:
> Quoting Niklas Haas (2023-10-14 13:46:34)
> > > 3. I don't see how the MJPEG encoder behaviour where the valid formats
> > > de facto depend upon strictness can be encoded in this way; isn't the
> > > aim to get rid of the necessity of the workaround in ffmpeg cli?
> > 
> > Note that ffmpeg cli presently initializes the filter graph well before
> > the AVCodecContext is set up with options, let alone opened. (Presently,
> > the logic for overriding the pixfmt list directly looks up the "strict"
> > field in the options dict)
> > 
> > So that limits the design space somewhat for elegant solutions here.
> > Either we make the "return list of supported formats" callback in
> > AVCodec simply accept the strict_std_compliance setting directly, or we
> > extend the static list of colorspaces itself by an extra strictness
> > field. Probably the former is better than the latter of these two
> > approaches.
> 
> FWIW I find that behaviour to be a disgusting hack and the cleanest way
> to address it would IMO be a separate mjpeg_experimental AVCodec
> instance. That is assuming anyone actually needs this functionality.
> Maybe we could also just drop it?

The usecase i remember was lossless jpeg, but this seems to support
it by default now

If there is still a usecase, then i agree *jpeg_experimental would be an
option. or maybe jpeg_somethingrange
maybe this is usefull for encoding some mjpeg variants. Somehow i think
they didnt all use the same range

thx

[...]
-- 
Michael     GnuPG fingerprint: 9FF2128B147EF6730BADF133611EC787040B0FAB

Elect your leaders based on what they did after the last election, not
based on what they say before an election.


[-- Attachment #1.2: signature.asc --]
[-- Type: application/pgp-signature, Size: 195 bytes --]

[-- Attachment #2: Type: text/plain, Size: 251 bytes --]

_______________________________________________
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 v2 02/13] avcodec: add extended AVCodec color metadata

[Anton Khirnov]

Quoting Andreas Rheinhardt (2023-10-13 19:10:33)
> Niklas Haas:
> > From: Niklas Haas <git@haasn.dev>
> > 
> > This is motivated primarily by a desire for YUVJ removal, which will
> > require signalling the supported color ranges as part of the codec
> > capabilities. But since we're here anyway, we might as well add all of
> > the metadata, which I foresee seeing more use in the future (e.g.
> > automatic conversion from HDR to SDR when encoding to formats that don't
> > support AVCOL_TRC_SMPTE2084, ...)
> > ---
> >  doc/APIchanges       | 4 ++++
> >  libavcodec/codec.h   | 7 +++++++
> >  libavcodec/version.h | 4 ++--
> >  3 files changed, 13 insertions(+), 2 deletions(-)
> > 
> > diff --git a/doc/APIchanges b/doc/APIchanges
> > index 9b109e6fa7..f91e855e70 100644
> > --- a/doc/APIchanges
> > +++ b/doc/APIchanges
> > @@ -2,6 +2,10 @@ The last version increases of all libraries were on 2023-02-09
> >  
> >  API changes, most recent first:
> >  
> > +2023-10-xx - xxxxxxxxxx - lavc 60.23.100 - avcodec.h
> > +  Add AVCodec.csps, AVCodec.color_ranges, AVCodec.chroma_locs, AVCodec.primaries,
> > +  AVCodec.trcs.
> > +
> >  2023-10-06 - xxxxxxxxxx - lavc 60.30.101 - avcodec.h
> >    AVCodecContext.coded_side_data may now be used during decoding, to be set
> >    by user before calling avcodec_open2() for initialization.
> > diff --git a/libavcodec/codec.h b/libavcodec/codec.h
> > index 8034f1a53c..5bc8f21868 100644
> > --- a/libavcodec/codec.h
> > +++ b/libavcodec/codec.h
> > @@ -235,6 +235,13 @@ typedef struct AVCodec {
> >       * Array of supported channel layouts, terminated with a zeroed layout.
> >       */
> >      const AVChannelLayout *ch_layouts;
> > +
> > +    /* Extended colorspace support metadata */
> > +    const enum AVColorSpace *csps;                  ///< array of supported color spaces, or NULL if unknown, array is terminated by AVCOL_SPC_UNSPECIFIED
> > +    const enum AVColorRange *color_ranges;          ///< array of supported color ranges, or NULL if unknown, array is terminated by 0
> > +    const enum AVChromaLocation *chroma_locs;       ///< array of supported chroma locations, or NULL if unknown, array is terminated by 0
> > +    const enum AVColorPrimaries *primaries;         ///< array of supported color primaries, or NULL if unknown, array is terminated by 0
> > +    const enum AVColorTransferCharacteristic *trcs; ///< array of supported transfer characteristics, or NULL if known, array is terminated by 0
> >  } AVCodec;
> >  
> 
> This design has several drawbacks:
> 1. It adds stuff that will only be set by a tiny minority of AVCodec's
> to all of them.
> 2. It is based around the underlying assumption that the set of
> permissible states (tupels) is a cartesian product of a set of color
> spaces, a set of color ranges etc. This is wrong: E.g. VP9 disallows
> limited-range RGB (it is syntactically impossible to set the color range
> when using RGB color space).
> 3. I don't see how the MJPEG encoder behaviour where the valid formats
> de facto depend upon strictness can be encoded in this way; isn't the
> aim to get rid of the necessity of the workaround in ffmpeg cli?
> 
> 1. and 2. suggests using some form of function that returns a list of
> supported tupels;

Another argument in favor of a function instead of arrays directly in
AVCodec is that for some codecs this is determined at runtime. A
function would allow us to get rid of FFCodec.init_static_data and make
FFCodec const.

-- 
Anton Khirnov
_______________________________________________
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 v2 02/13] avcodec: add extended AVCodec color metadata

[Leo Izen]

On 10/13/23 10:24, Niklas Haas wrote:
> From: Niklas Haas <git@haasn.dev>
> 
> This is motivated primarily by a desire for YUVJ removal, which will
> require signalling the supported color ranges as part of the codec
> capabilities. But since we're here anyway, we might as well add all of
> the metadata, which I foresee seeing more use in the future (e.g.
> automatic conversion from HDR to SDR when encoding to formats that don't
> support AVCOL_TRC_SMPTE2084, ...)
> ---
> +
> +    /* Extended colorspace support metadata */
> +    const enum AVColorSpace *csps;                  ///< array of supported color spaces, or NULL if unknown, array is terminated by AVCOL_SPC_UNSPECIFIED
> +    const enum AVColorRange *color_ranges;          ///< array of supported color ranges, or NULL if unknown, array is terminated by 0
> +    const enum AVChromaLocation *chroma_locs;       ///< array of supported chroma locations, or NULL if unknown, array is terminated by 0
> +    const enum AVColorPrimaries *primaries;         ///< array of supported color primaries, or NULL if unknown, array is terminated by 0
> +    const enum AVColorTransferCharacteristic *trcs; ///< array of supported transfer characteristics, or NULL if known, array is terminated by 0
>   } AVCodec;


Any particular reason we're using AVCOL_SPC_UNSPECIFIED to terminate 
csps, but not using AVCOL_PRI_UNSPECIFIED for the primaries and the 
equivalent for the TRC? It seems a bit more consistent than using RESERVED0

- Leo Izen (Traneptora)

_______________________________________________
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 v2 02/13] avcodec: add extended AVCodec color metadata

[Niklas Haas]

On Sat, 14 Oct 2023 09:31:32 -0400 Leo Izen <leo.izen@gmail.com> wrote:
> On 10/13/23 10:24, Niklas Haas wrote:
> > From: Niklas Haas <git@haasn.dev>
> > 
> > This is motivated primarily by a desire for YUVJ removal, which will
> > require signalling the supported color ranges as part of the codec
> > capabilities. But since we're here anyway, we might as well add all of
> > the metadata, which I foresee seeing more use in the future (e.g.
> > automatic conversion from HDR to SDR when encoding to formats that don't
> > support AVCOL_TRC_SMPTE2084, ...)
> > ---
> > +
> > +    /* Extended colorspace support metadata */
> > +    const enum AVColorSpace *csps;                  ///< array of supported color spaces, or NULL if unknown, array is terminated by AVCOL_SPC_UNSPECIFIED
> > +    const enum AVColorRange *color_ranges;          ///< array of supported color ranges, or NULL if unknown, array is terminated by 0
> > +    const enum AVChromaLocation *chroma_locs;       ///< array of supported chroma locations, or NULL if unknown, array is terminated by 0
> > +    const enum AVColorPrimaries *primaries;         ///< array of supported color primaries, or NULL if unknown, array is terminated by 0
> > +    const enum AVColorTransferCharacteristic *trcs; ///< array of supported transfer characteristics, or NULL if known, array is terminated by 0
> >   } AVCodec;
> 
> 
> Any particular reason we're using AVCOL_SPC_UNSPECIFIED to terminate 
> csps, but not using AVCOL_PRI_UNSPECIFIED for the primaries and the 
> equivalent for the TRC? It seems a bit more consistent than using RESERVED0

To be clear, we are - AVCOL_PRI/TRC_UNSPECIFIED are equal to 0, unlike
the other fields. But I could change the comments here for clarity.
_______________________________________________
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 v2 03/13] fftools/ffmpeg_filter: auto-convert range if needed

[Niklas Haas]

From: Niklas Haas <git@haasn.dev>

To convert between color ranges, if needed by the codec properties. We
momentarily duplicate the mjpeg strictness logic to also enfoce full
range. This duplication will be cleaned up in the next commit.

Due to avcodec_open2 being called after ofilter_bind_ost, we need to
look up the eventual encoder options from the options dictionary
directly, following the same design as the "strict" option.
---
 fftools/ffmpeg_filter.c | 61 +++++++++++++++++++++++++++++++++++------
 1 file changed, 52 insertions(+), 9 deletions(-)

diff --git a/fftools/ffmpeg_filter.c b/fftools/ffmpeg_filter.c
index c738fc3397..acdfa72043 100644
--- a/fftools/ffmpeg_filter.c
+++ b/fftools/ffmpeg_filter.c
@@ -169,6 +169,7 @@ typedef struct OutputFilterPriv {
     int width, height;
     int sample_rate;
     AVChannelLayout ch_layout;
+    enum AVColorRange range;
 
     // time base in which the output is sent to our downstream
     // does not need to match the filtersink's timebase
@@ -184,6 +185,7 @@ typedef struct OutputFilterPriv {
     const int *formats;
     const AVChannelLayout *ch_layouts;
     const int *sample_rates;
+    const enum AVColorRange *ranges;
 
     AVRational enc_timebase;
     // offset for output timestamps, in AV_TIME_BASE_Q
@@ -368,6 +370,9 @@ DEF_CHOOSE_FORMAT(sample_fmts, enum AVSampleFormat, format, formats,
 DEF_CHOOSE_FORMAT(sample_rates, int, sample_rate, sample_rates, 0,
                   "%d", )
 
+DEF_CHOOSE_FORMAT(out_range, enum AVColorRange, range, ranges,
+                  AVCOL_RANGE_UNSPECIFIED, "%s", av_color_range_name);
+
 static void choose_channel_layouts(OutputFilterPriv *ofp, AVBPrint *bprint)
 {
     if (av_channel_layout_check(&ofp->ch_layout)) {
@@ -662,6 +667,17 @@ static int set_channel_layout(OutputFilterPriv *f, OutputStream *ost)
     return 0;
 }
 
+static int ost_opt_int(OutputStream *ost, const char *name, int defval)
+{
+    const AVDictionaryEntry *e = av_dict_get(ost->encoder_opts, name, NULL, 0);
+    if (e) {
+        const AVOption *o = av_opt_find(ost->enc_ctx, e->key, NULL, 0, 0);
+        av_assert0(o);
+        av_opt_eval_int(ost->enc_ctx, o, e->value, &defval);
+    }
+    return defval;
+}
+
 int ofilter_bind_ost(OutputFilter *ofilter, OutputStream *ost)
 {
     const OutputFile  *of = output_files[ost->file_index];
@@ -669,6 +685,7 @@ int ofilter_bind_ost(OutputFilter *ofilter, OutputStream *ost)
     FilterGraph  *fg = ofilter->graph;
     FilterGraphPriv *fgp = fgp_from_fg(fg);
     const AVCodec *c = ost->enc_ctx->codec;
+    enum AVColorRange color_range;
 
     av_assert0(!ofilter->ost);
 
@@ -682,6 +699,26 @@ int ofilter_bind_ost(OutputFilter *ofilter, OutputStream *ost)
     case AVMEDIA_TYPE_VIDEO:
         ofp->width      = ost->enc_ctx->width;
         ofp->height     = ost->enc_ctx->height;
+        color_range     = ost_opt_int(ost, "color_range", ost->enc_ctx->color_range);
+        if (color_range != AVCOL_RANGE_UNSPECIFIED) {
+            ofp->range = color_range;
+        } else {
+            ofp->ranges = c->color_ranges;
+
+            // MJPEG encoder exports a full list of supported pixel formats,
+            // but the full-range ones are experimental-only.
+            // Restrict the auto-conversion list unless -strict experimental
+            // has been specified.
+            if (!strcmp(c->name, "mjpeg")) {
+                static const enum AVColorRange mjpeg_ranges[] =
+                    { AVCOL_RANGE_JPEG, AVCOL_RANGE_UNSPECIFIED };
+
+                int strict_val = ost->enc_ctx->strict_std_compliance;
+                strict_val = ost_opt_int(ost, "strict", strict_val);
+                if (strict_val > FF_COMPLIANCE_UNOFFICIAL)
+                    ofp->ranges = mjpeg_ranges;
+            }
+        }
         if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
             ofp->format = ost->enc_ctx->pix_fmt;
         } else {
@@ -1149,6 +1186,7 @@ static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter,
     OutputFilterPriv *ofp = ofp_from_ofilter(ofilter);
     OutputStream *ost = ofilter->ost;
     OutputFile    *of = output_files[ost->file_index];
+    FilterGraphPriv *fgp = fgp_from_fg(fg);
     AVFilterContext *last_filter = out->filter_ctx;
     AVBPrint bprint;
     int pad_idx = out->pad_idx;
@@ -1164,22 +1202,27 @@ static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter,
     if (ret < 0)
         return ret;
 
-    if ((ofp->width || ofp->height) && ofilter->ost->autoscale) {
-        char args[255];
+    av_bprint_init(&bprint, 0, AV_BPRINT_SIZE_UNLIMITED);
+    if ((ofp->width || ofp->height) && ofilter->ost->autoscale)
+        av_bprintf(&bprint, "w=%d:h=%d:", ofp->width, ofp->height);
+    if (!fgp->disable_conversions)
+        choose_out_range(ofp, &bprint);
+    if (bprint.len) {
         AVFilterContext *filter;
         const AVDictionaryEntry *e = NULL;
 
-        snprintf(args, sizeof(args), "%d:%d",
-                 ofp->width, ofp->height);
+        while ((e = av_dict_iterate(ost->sws_dict, e)))
+            av_bprintf(&bprint, "%s=%s:", e->key, e->value);
 
-        while ((e = av_dict_iterate(ost->sws_dict, e))) {
-            av_strlcatf(args, sizeof(args), ":%s=%s", e->key, e->value);
-        }
+        if (!av_bprint_is_complete(&bprint))
+            return AVERROR(ENOMEM);
 
         snprintf(name, sizeof(name), "scaler_out_%d_%d",
                  ost->file_index, ost->index);
-        if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
-                                                name, args, NULL, fg->graph)) < 0)
+        ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
+                                           name, bprint.str, NULL, fg->graph);
+        av_bprint_finalize(&bprint, NULL);
+        if (ret < 0)
             return ret;
         if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
             return ret;
-- 
2.42.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 v2 04/13] lavfi/vf_colorspace: support prim/trc/csp passthrough

[Niklas Haas]

From: Niklas Haas <git@haasn.dev>

Setting the output range/primaries/colorspace to unspecified now infers
the value from the input signal. If the input signal also has unknown
prim/trc, and no specific output is requested, enable passthrough mode.

As a technical implementation detail, define a static const sentinel
struct to represent "unknown" values. This is to avoid reconfiguring the
filter on every frame (which is guarded by s->out_primaries etc. being
NULL), as well as make the memcmp NOOP check succeed.
---
 libavfilter/vf_colorspace.c | 71 ++++++++++++++++---------------------
 1 file changed, 30 insertions(+), 41 deletions(-)

diff --git a/libavfilter/vf_colorspace.c b/libavfilter/vf_colorspace.c
index 2a30434401..5ab5266ef0 100644
--- a/libavfilter/vf_colorspace.c
+++ b/libavfilter/vf_colorspace.c
@@ -442,29 +442,23 @@ static int create_filtergraph(AVFilterContext *ctx,
         if (s->user_iprm != AVCOL_PRI_UNSPECIFIED)
             s->in_prm = s->user_iprm;
         s->in_primaries = av_csp_primaries_desc_from_id(s->in_prm);
-        if (!s->in_primaries) {
+        s->out_prm = out->color_primaries;
+        s->out_primaries = av_csp_primaries_desc_from_id(s->out_prm);
+        if (s->out_prm == AVCOL_PRI_UNSPECIFIED || s->fast_mode) {
+            static const AVColorPrimariesDesc unknown = {0};
+            s->in_primaries = s->out_primaries = &unknown; /* force passthrough */
+        } else if (!s->in_primaries) {
             av_log(ctx, AV_LOG_ERROR,
                    "Unsupported input primaries %d (%s)\n",
                    s->in_prm, av_color_primaries_name(s->in_prm));
             return AVERROR(EINVAL);
-        }
-        s->out_prm = out->color_primaries;
-        s->out_primaries = av_csp_primaries_desc_from_id(s->out_prm);
-        if (!s->out_primaries) {
-            if (s->out_prm == AVCOL_PRI_UNSPECIFIED) {
-                if (s->user_all == CS_UNSPECIFIED) {
-                    av_log(ctx, AV_LOG_ERROR, "Please specify output primaries\n");
-                } else {
-                    av_log(ctx, AV_LOG_ERROR,
-                           "Unsupported output color property %d\n", s->user_all);
-                }
-            } else {
-                av_log(ctx, AV_LOG_ERROR,
-                       "Unsupported output primaries %d (%s)\n",
-                       s->out_prm, av_color_primaries_name(s->out_prm));
-            }
+        } else if (!s->out_primaries) {
+            av_log(ctx, AV_LOG_ERROR,
+                   "Unsupported output primaries %d (%s)\n",
+                   s->out_prm, av_color_primaries_name(s->out_prm));
             return AVERROR(EINVAL);
         }
+
         s->lrgb2lrgb_passthrough = !memcmp(s->in_primaries, s->out_primaries,
                                            sizeof(*s->in_primaries));
         if (!s->lrgb2lrgb_passthrough) {
@@ -505,38 +499,33 @@ static int create_filtergraph(AVFilterContext *ctx,
         if (s->user_itrc != AVCOL_TRC_UNSPECIFIED)
             s->in_trc = s->user_itrc;
         s->in_txchr = get_transfer_characteristics(s->in_trc);
-        if (!s->in_txchr) {
-            av_log(ctx, AV_LOG_ERROR,
-                   "Unsupported input transfer characteristics %d (%s)\n",
-                   s->in_trc, av_color_transfer_name(s->in_trc));
-            return AVERROR(EINVAL);
-        }
     }
 
     if (!s->out_txchr) {
         av_freep(&s->lin_lut);
         s->out_trc = out->color_trc;
         s->out_txchr = get_transfer_characteristics(s->out_trc);
-        if (!s->out_txchr) {
-            if (s->out_trc == AVCOL_TRC_UNSPECIFIED) {
-                if (s->user_all == CS_UNSPECIFIED) {
-                    av_log(ctx, AV_LOG_ERROR,
-                           "Please specify output transfer characteristics\n");
-                } else {
-                    av_log(ctx, AV_LOG_ERROR,
-                           "Unsupported output color property %d\n", s->user_all);
-                }
-            } else {
-                av_log(ctx, AV_LOG_ERROR,
-                       "Unsupported output transfer characteristics %d (%s)\n",
-                       s->out_trc, av_color_transfer_name(s->out_trc));
-            }
-            return AVERROR(EINVAL);
-        }
     }
 
-    s->rgb2rgb_passthrough = s->fast_mode || (s->lrgb2lrgb_passthrough &&
-                             !memcmp(s->in_txchr, s->out_txchr, sizeof(*s->in_txchr)));
+    if ((s->out_trc == AVCOL_TRC_UNSPECIFIED && s->lrgb2lrgb_passthrough) || s->fast_mode) {
+        static const struct TransferCharacteristics unknown = {0};
+        s->in_txchr = s->out_txchr = &unknown; /* force passthrough */
+    } else if (!s->in_txchr) {
+        av_log(ctx, AV_LOG_ERROR,
+               "Unsupported input transfer characteristics %d (%s)\n",
+               s->in_trc, av_color_transfer_name(s->in_trc));
+        return AVERROR(EINVAL);
+    } else if (s->out_trc == AVCOL_TRC_UNSPECIFIED) {
+        s->out_txchr = s->in_txchr;
+    } else if (!s->out_txchr) {
+        av_log(ctx, AV_LOG_ERROR,
+               "Unsupported output transfer characteristics %d (%s)\n",
+               s->out_trc, av_color_transfer_name(s->out_trc));
+        return AVERROR(EINVAL);
+    }
+
+    s->rgb2rgb_passthrough = s->lrgb2lrgb_passthrough &&
+                             !memcmp(s->in_txchr, s->out_txchr, sizeof(*s->in_txchr));
     if (!s->rgb2rgb_passthrough && !s->lin_lut) {
         res = fill_gamma_table(s);
         if (res < 0)
-- 
2.42.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 v2 05/13] fftools/ffmpeg_filter: auto-insert colorspace filter

[Niklas Haas]

From: Niklas Haas <git@haasn.dev>

To convert between color space/transfer/primaries, if needed by the
codec properties. Libswscale can't handle this at the moment, but
fortunately there exists vf_colorspace which we can use unconditionally.
---
 fftools/ffmpeg_filter.c | 65 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 65 insertions(+)

diff --git a/fftools/ffmpeg_filter.c b/fftools/ffmpeg_filter.c
index acdfa72043..41758ac2b5 100644
--- a/fftools/ffmpeg_filter.c
+++ b/fftools/ffmpeg_filter.c
@@ -170,6 +170,9 @@ typedef struct OutputFilterPriv {
     int sample_rate;
     AVChannelLayout ch_layout;
     enum AVColorRange range;
+    enum AVColorSpace csp;
+    enum AVColorPrimaries prim;
+    enum AVColorTransferCharacteristic trc;
 
     // time base in which the output is sent to our downstream
     // does not need to match the filtersink's timebase
@@ -186,6 +189,9 @@ typedef struct OutputFilterPriv {
     const AVChannelLayout *ch_layouts;
     const int *sample_rates;
     const enum AVColorRange *ranges;
+    const enum AVColorSpace *csps;
+    const enum AVColorPrimaries *prims;
+    const enum AVColorTransferCharacteristic *trcs;
 
     AVRational enc_timebase;
     // offset for output timestamps, in AV_TIME_BASE_Q
@@ -373,6 +379,15 @@ DEF_CHOOSE_FORMAT(sample_rates, int, sample_rate, sample_rates, 0,
 DEF_CHOOSE_FORMAT(out_range, enum AVColorRange, range, ranges,
                   AVCOL_RANGE_UNSPECIFIED, "%s", av_color_range_name);
 
+DEF_CHOOSE_FORMAT(space, enum AVColorSpace, csp, csps,
+                  AVCOL_SPC_UNSPECIFIED, "%s", av_color_space_name);
+
+DEF_CHOOSE_FORMAT(primaries, enum AVColorPrimaries, prim, prims,
+                  AVCOL_PRI_UNSPECIFIED, "%s", av_color_primaries_name);
+
+DEF_CHOOSE_FORMAT(trc, enum AVColorTransferCharacteristic, trc, trcs,
+                  AVCOL_TRC_UNSPECIFIED, "%s", av_color_transfer_name);
+
 static void choose_channel_layouts(OutputFilterPriv *ofp, AVBPrint *bprint)
 {
     if (av_channel_layout_check(&ofp->ch_layout)) {
@@ -599,6 +614,9 @@ static OutputFilter *ofilter_alloc(FilterGraph *fg)
     ofilter           = &ofp->ofilter;
     ofilter->graph    = fg;
     ofp->format       = -1;
+    ofp->csp          = AVCOL_SPC_UNSPECIFIED;
+    ofp->prim         = AVCOL_PRI_UNSPECIFIED;
+    ofp->trc          = AVCOL_TRC_UNSPECIFIED;
     ofilter->last_pts = AV_NOPTS_VALUE;
 
     return ofilter;
@@ -686,6 +704,9 @@ int ofilter_bind_ost(OutputFilter *ofilter, OutputStream *ost)
     FilterGraphPriv *fgp = fgp_from_fg(fg);
     const AVCodec *c = ost->enc_ctx->codec;
     enum AVColorRange color_range;
+    enum AVColorPrimaries color_primaries;
+    enum AVColorTransferCharacteristic color_trc;
+    enum AVColorSpace color_space;
 
     av_assert0(!ofilter->ost);
 
@@ -700,6 +721,9 @@ int ofilter_bind_ost(OutputFilter *ofilter, OutputStream *ost)
         ofp->width      = ost->enc_ctx->width;
         ofp->height     = ost->enc_ctx->height;
         color_range     = ost_opt_int(ost, "color_range", ost->enc_ctx->color_range);
+        color_primaries = ost_opt_int(ost, "color_primaries", ost->enc_ctx->color_primaries);
+        color_trc       = ost_opt_int(ost, "color_trc", ost->enc_ctx->color_trc);
+        color_space     = ost_opt_int(ost, "colorspace", ost->enc_ctx->colorspace);
         if (color_range != AVCOL_RANGE_UNSPECIFIED) {
             ofp->range = color_range;
         } else {
@@ -719,6 +743,21 @@ int ofilter_bind_ost(OutputFilter *ofilter, OutputStream *ost)
                     ofp->ranges = mjpeg_ranges;
             }
         }
+        if (color_primaries != AVCOL_PRI_UNSPECIFIED) {
+            ofp->prim = color_primaries;
+        } else {
+            ofp->prims = c->primaries;
+        }
+        if (color_trc != AVCOL_TRC_UNSPECIFIED) {
+            ofp->trc = color_trc;
+        } else {
+            ofp->trcs = c->trcs;
+        }
+        if (color_space != AVCOL_SPC_UNSPECIFIED) {
+            ofp->csp = color_space;
+        } else {
+            ofp->csps = c->csps;
+        }
         if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
             ofp->format = ost->enc_ctx->pix_fmt;
         } else {
@@ -1231,6 +1270,32 @@ static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter,
         pad_idx = 0;
     }
 
+    if (!fgp->disable_conversions) {
+        av_bprint_init(&bprint, 0, AV_BPRINT_SIZE_UNLIMITED);
+        choose_space(ofp,     &bprint);
+        choose_primaries(ofp, &bprint);
+        choose_trc(ofp,       &bprint);
+        if (!av_bprint_is_complete(&bprint))
+            return AVERROR(ENOMEM);
+        if (bprint.len) {
+            AVFilterContext *filter;
+
+            snprintf(name, sizeof(name), "csp_out_%d_%d",
+                     ost->file_index, ost->index);
+            ret = avfilter_graph_create_filter(&filter,
+                                               avfilter_get_by_name("colorspace"),
+                                               name, bprint.str, NULL, fg->graph);
+            av_bprint_finalize(&bprint, NULL);
+            if (ret < 0)
+                return ret;
+            if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
+                return ret;
+
+            last_filter = filter;
+            pad_idx = 0;
+        }
+    }
+
     av_bprint_init(&bprint, 0, AV_BPRINT_SIZE_UNLIMITED);
     ret = choose_pix_fmts(ofilter, &bprint, &pix_fmts);
     if (ret < 0)
-- 
2.42.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 v2 06/13] avcodec/encode: enforce AVCodec capabilities at encode time

[Niklas Haas]

From: Niklas Haas <git@haasn.dev>

In general, the logic is always the same: if the codec supports only a
single format, enforce it if possible. Otherwise, throw an error when
an incompatible format is thrown.

To preserve backwards compatibility and make this check less pedantic
than it needs to be, always consider 'AVCOL_*_UNKNOWN/UNSPECIFIED' a
valid value. That way, we will only throw an error if the user
explicitly set a color value that we explicitly know is unsupported.
---
 libavcodec/encode.c | 102 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 102 insertions(+)

diff --git a/libavcodec/encode.c b/libavcodec/encode.c
index a436be2657..f22b17f33e 100644
--- a/libavcodec/encode.c
+++ b/libavcodec/encode.c
@@ -611,6 +611,108 @@ static int encode_preinit_video(AVCodecContext *avctx)
             avctx->color_range = AVCOL_RANGE_JPEG;
     }
 
+    if (c->csps) {
+        for (i = 0; c->csps[i] != AVCOL_SPC_UNSPECIFIED; i++)
+            if (avctx->colorspace == c->csps[i])
+                break;
+        if (c->csps[i] == AVCOL_SPC_UNSPECIFIED) {
+            av_log(avctx, AV_LOG_ERROR,
+                   "Specified colorspace %s is not supported by the %s encoder.\n",
+                   av_color_space_name(avctx->colorspace), c->name);
+            av_log(avctx, AV_LOG_ERROR, "Supported colorspaces:\n");
+            for (int p = 0; c->csps[p] != AVCOL_SPC_UNSPECIFIED; p++) {
+                av_log(avctx, AV_LOG_ERROR, "  %s\n",
+                       av_color_space_name(c->csps[p]));
+            }
+            return AVERROR(EINVAL);
+        }
+    }
+
+    if (c->color_ranges) {
+        for (i = 0; c->color_ranges[i] != AVCOL_RANGE_UNSPECIFIED; i++) {
+            if (avctx->color_range == c->color_ranges[i])
+                break;
+        }
+        if (c->color_ranges[i] == AVCOL_RANGE_UNSPECIFIED) {
+            if (i == 1 && !avctx->color_range) {
+                avctx->color_range = c->color_ranges[0];
+            } else if (avctx->color_range) {
+                av_log(avctx, AV_LOG_ERROR,
+                       "Specified color range %s is not supported by the %s encoder.\n",
+                       av_color_range_name(avctx->color_range), c->name);
+                av_log(avctx, AV_LOG_ERROR, "Supported color ranges:\n");
+                for (int p = 0; c->color_ranges[p] != AVCOL_RANGE_UNSPECIFIED; p++) {
+                    av_log(avctx, AV_LOG_ERROR, "  %s\n",
+                           av_color_range_name(c->color_ranges[p]));
+                }
+                return AVERROR(EINVAL);
+            }
+        }
+    }
+
+    if (c->chroma_locs) {
+        for (i = 0; c->chroma_locs[i] != AVCHROMA_LOC_UNSPECIFIED; i++)
+            if (avctx->chroma_sample_location == c->chroma_locs[i])
+                break;
+        if (c->chroma_locs[i] == AVCHROMA_LOC_UNSPECIFIED) {
+            if (i == 1 && !avctx->chroma_sample_location) {
+                avctx->chroma_sample_location = c->chroma_locs[0];
+            } else if (avctx->chroma_sample_location) {
+                av_log(avctx, AV_LOG_ERROR,
+                       "Specified chroma sample location %s is not supported by the %s encoder.\n",
+                       av_chroma_location_name(avctx->chroma_sample_location), c->name);
+                av_log(avctx, AV_LOG_ERROR, "Supported chroma sample locations:\n");
+                for (int p = 0; c->chroma_locs[p] != AVCHROMA_LOC_UNSPECIFIED; p++) {
+                    av_log(avctx, AV_LOG_ERROR, "  %s\n",
+                           av_chroma_location_name(c->chroma_locs[p]));
+                }
+                return AVERROR(EINVAL);
+            }
+        }
+    }
+
+    if (c->primaries) {
+        for (i = 0; c->primaries[i] != AVCOL_PRI_UNSPECIFIED; i++)
+            if (avctx->color_primaries == c->primaries[i])
+                break;
+        if (c->primaries[i] == AVCOL_PRI_UNSPECIFIED) {
+            if (i == 1 && !avctx->color_primaries) {
+                avctx->color_primaries = c->primaries[0];
+            } else if (avctx->color_primaries) {
+                av_log(avctx, AV_LOG_ERROR,
+                       "Specified color primaries %s is not supported by the %s encoder.\n",
+                       av_color_primaries_name(avctx->color_primaries), c->name);
+                av_log(avctx, AV_LOG_ERROR, "Supported color primaries:\n");
+                for (int p = 0; c->primaries[p] != AVCOL_PRI_UNSPECIFIED; p++) {
+                    av_log(avctx, AV_LOG_ERROR, "  %s\n",
+                           av_color_primaries_name(c->primaries[p]));
+                }
+                return AVERROR(EINVAL);
+            }
+        }
+    }
+
+    if (c->trcs) {
+        for (i = 0; c->trcs[i] != AVCOL_TRC_UNSPECIFIED; i++)
+            if (avctx->color_trc == c->trcs[i])
+                break;
+        if (c->trcs[i] == AVCOL_TRC_UNSPECIFIED) {
+            if (i == 1 && !avctx->color_trc) {
+                avctx->color_trc = c->trcs[0];
+            } else if (avctx->color_trc) {
+                av_log(avctx, AV_LOG_ERROR,
+                       "Specified color transfer characteristics %s is not supported by the %s encoder.\n",
+                       av_color_transfer_name(avctx->color_trc), c->name);
+                av_log(avctx, AV_LOG_ERROR, "Supported color transfer characteristics:\n");
+                for (int p = 0; c->trcs[p] != AVCOL_TRC_UNSPECIFIED; p++) {
+                    av_log(avctx, AV_LOG_ERROR, "  %s\n",
+                           av_color_transfer_name(c->trcs[p]));
+                }
+                return AVERROR(EINVAL);
+            }
+        }
+    }
+
     if (    avctx->bits_per_raw_sample < 0
         || (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) {
         av_log(avctx, AV_LOG_WARNING, "Specified bit depth %d not possible with the specified pixel formats depth %d\n",
-- 
2.42.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 v2 07/13] tests/fate: force MPEG range for rawvideo tests

[Niklas Haas]

From: Niklas Haas <git@haasn.dev>

The input file is MPEG range, so we should also encode to MPEG range
before comparing against it. This bug was avoided in the past because
JPEG range YUV inputs were tagged as YUVJ, which resulted in an
automatic conversion to PC range by default.

After YUVJ removal, we will need to explicitly specify that we want MPEG
range, since rawvideo does not care (or signal) if the output is JPEG or
MPEG range.

Affects both vsynth and owdenoise.
---
 tests/fate/filter-video.mak | 2 +-
 tests/fate/vcodec.mak       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/fate/filter-video.mak b/tests/fate/filter-video.mak
index 789ec6414c..3aef652244 100644
--- a/tests/fate/filter-video.mak
+++ b/tests/fate/filter-video.mak
@@ -2,7 +2,7 @@
 VIDEO_FILTER = $(call ALLYES, $(1:%=%_FILTER) $(2) FILE_PROTOCOL IMAGE2_DEMUXER PGMYUV_DECODER RAWVIDEO_ENCODER NUT_MUXER MD5_PROTOCOL)
 
 FATE_FILTER_SAMPLES-$(call FILTERDEMDECENCMUX, PERMS OWDENOISE TRIM SCALE, SMJPEG, MJPEG, RAWVIDEO, RAWVIDEO, PIPE_PROTOCOL) += fate-filter-owdenoise-sample
-fate-filter-owdenoise-sample: CMD = ffmpeg -auto_conversion_filters -idct simple -i $(TARGET_SAMPLES)/smjpeg/scenwin.mjpg -vf "trim=duration=0.5,perms=random,owdenoise=10:20:20:enable=not(between(t\,0.2\,1.2))" -an -f rawvideo -
+fate-filter-owdenoise-sample: CMD = ffmpeg -auto_conversion_filters -idct simple -i $(TARGET_SAMPLES)/smjpeg/scenwin.mjpg -vf "trim=duration=0.5,perms=random,owdenoise=10:20:20:enable=not(between(t\,0.2\,1.2))" -an -f rawvideo -color_range mpeg -
 fate-filter-owdenoise-sample: REF = $(SAMPLES)/filter-reference/owdenoise-scenwin.raw
 fate-filter-owdenoise-sample: CMP_TARGET = 1
 fate-filter-owdenoise-sample: FUZZ = 3539
diff --git a/tests/fate/vcodec.mak b/tests/fate/vcodec.mak
index 45ed88da96..f7f474c146 100644
--- a/tests/fate/vcodec.mak
+++ b/tests/fate/vcodec.mak
@@ -6,7 +6,7 @@ fate-vsynth%: CODEC = $(word 3, $(subst -, ,$(@)))
 fate-vsynth%: FMT = avi
 fate-vsynth%: DEFAULT_SIZE = -s 352x288
 fate-vsynth3-%: DEFAULT_SIZE = -s $(FATEW)x$(FATEH)
-fate-vsynth%: CMD = enc_dec "rawvideo $(DEFAULT_SIZE) -pix_fmt yuv420p $(RAWDECOPTS)" $(SRC) $(FMT) "-c $(CODEC) $(ENCOPTS)" rawvideo "-pix_fmt yuv420p -vsync passthrough $(DECOPTS)" "" "" ${TWOPASS}
+fate-vsynth%: CMD = enc_dec "rawvideo $(DEFAULT_SIZE) -pix_fmt yuv420p $(RAWDECOPTS)" $(SRC) $(FMT) "-c $(CODEC) $(ENCOPTS)" rawvideo "-pix_fmt yuv420p -color_range mpeg -vsync passthrough $(DECOPTS)" "" "" ${TWOPASS}
 fate-vsynth%: CMP_UNIT = 1
 fate-vsynth%: REF = $(SRC_PATH)/tests/ref/vsynth/$(@:fate-%=%)
 
-- 
2.42.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 v2 08/13] tests/fate: allow conversion filters in jpg-icc test

[Niklas Haas]

From: Niklas Haas <git@haasn.dev>

This requires conversion from full to limited range JPEG, as mjpeg only
accepts limited range (without extra strictness options). The old
solution to this problem was to manually insert -vf scale, but this does
not work in the absencee of YUVJ as vf_scale cannot (yet) negotiate the
required colorspace range. The simple solution is to enable
auto-conversion filters, which allows fftools to insert the correct
conversion filter.
---
 tests/fate/image.mak | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/fate/image.mak b/tests/fate/image.mak
index 400199c28a..22c809be36 100644
--- a/tests/fate/image.mak
+++ b/tests/fate/image.mak
@@ -358,7 +358,7 @@ FATE_JPG += fate-jpg-rgb-5
 fate-jpg-rgb-5: CMD = framecrc -idct simple -i $(TARGET_SAMPLES)/jpg/jpg-8930-5.jpg
 
 FATE_JPG_TRANSCODE-$(call TRANSCODE, MJPEG, MJPEG IMAGE_JPEG_PIPE, IMAGE_PNG_PIPE_DEMUXER PNG_DECODER SCALE_FILTER) += fate-jpg-icc
-fate-jpg-icc: CMD = transcode png_pipe $(TARGET_SAMPLES)/png1/lena-int_rgb24.png mjpeg "-vf scale" "" "-show_frames"
+fate-jpg-icc: CMD = transcode png_pipe $(TARGET_SAMPLES)/png1/lena-int_rgb24.png mjpeg "-auto_conversion_filters" "" "-show_frames"
 
 FATE_JPG-$(call DEMDEC, IMAGE2, MJPEG) += $(FATE_JPG)
 FATE_IMAGE_FRAMECRC += $(FATE_JPG-yes)
-- 
2.42.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 v2 09/13] lavc: set color_ranges for YUVJ-only codecs

[Niklas Haas]

From: Niklas Haas <git@haasn.dev>

Only affects amv and roqvideo. (mjpeg is handled separately by fftools)
---
 libavcodec/mjpegenc.c    | 3 +++
 libavcodec/roqvideoenc.c | 2 ++
 2 files changed, 5 insertions(+)

diff --git a/libavcodec/mjpegenc.c b/libavcodec/mjpegenc.c
index 508772987f..c827a47e59 100644
--- a/libavcodec/mjpegenc.c
+++ b/libavcodec/mjpegenc.c
@@ -685,6 +685,9 @@ const FFCodec ff_amv_encoder = {
     .p.pix_fmts     = (const enum AVPixelFormat[]) {
         AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_NONE
     },
+    .p.color_ranges = (const enum AVColorRange[]) {
+        AVCOL_RANGE_JPEG, AVCOL_RANGE_UNSPECIFIED
+    },
     .p.priv_class   = &amv_class,
     .p.capabilities = AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
 };
diff --git a/libavcodec/roqvideoenc.c b/libavcodec/roqvideoenc.c
index 0933abf4f9..b584ee1142 100644
--- a/libavcodec/roqvideoenc.c
+++ b/libavcodec/roqvideoenc.c
@@ -1127,6 +1127,8 @@ const FFCodec ff_roq_encoder = {
     .close                = roq_encode_end,
     .p.pix_fmts           = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUVJ444P,
                                                         AV_PIX_FMT_NONE },
+    .p.color_ranges       = (const enum AVColorRange[]){ AVCOL_RANGE_JPEG,
+                                                        AVCOL_RANGE_UNSPECIFIED },
     .p.priv_class   = &roq_class,
     .caps_internal        = FF_CODEC_CAP_INIT_CLEANUP,
 };
-- 
2.42.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 v2 10/13] lavfi/lavu/lavc: remove YUVJ pixel formats

[Niklas Haas]

From: Niklas Haas <git@haasn.dev>

To avoid regressing any particular filter or codec, and to ensure every
commit still passes FATE while bisecting, removal of the YUVJ pixel
format and removal of YUVJ pixel format handling code was done in a
single, atomic commit.

Because this is a broad, sweeping change, the commit touches very many
places in the code. However, while this commit is very large, all of the
changes can be described as either:

- Setting the pixel format to YUV instead of YUVJ (for decoders which
  already correctly set range metadata)
- Removing YUVJ from pixel format lists (for filters/encoders that already
  natively handle color range metadata correctly)
- Replacing `pix_fmt = YUVJ` by `pix_fmt = YUV, color_ranges = JPEG`
  (for encoders which only supported YUVJ)
- Replacing a check of type (range == JPEG || pixfmt == YUVJ) by just
  (range == JPEG).

The only non-trivial exception to this is the change to ffmpeg_filter.c,
in which case the special handling of mjpeg was simply removed entirely,
since the new logic of setting c->color_ranges replaces it.
---
 doc/APIchanges                                |  4 ++
 fftools/ffmpeg_filter.c                       | 24 --------
 libavcodec/encode.c                           |  6 --
 libavcodec/fraps.c                            |  2 +-
 libavcodec/h264_slice.c                       | 26 +-------
 libavcodec/hevc_ps.c                          |  2 -
 libavcodec/hevcdec.c                          |  1 -
 libavcodec/libopenh264enc.c                   |  5 +-
 libavcodec/librav1e.c                         | 17 +-----
 libavcodec/libx264.c                          | 14 -----
 libavcodec/libx265.c                          | 14 +----
 libavcodec/ljpegenc.c                         |  1 -
 libavcodec/mdec.c                             |  2 +-
 libavcodec/mjpegdec.c                         | 28 ++++-----
 libavcodec/mjpegenc.c                         |  3 +-
 libavcodec/mjpegenc_common.c                  |  2 +-
 libavcodec/mpegvideo_enc.c                    |  3 -
 libavcodec/nvenc.c                            |  9 +--
 libavcodec/qsv.c                              |  1 -
 libavcodec/raw.c                              | 14 -----
 libavcodec/roqvideodec.c                      |  2 +-
 libavcodec/roqvideoenc.c                      |  2 +-
 libavcodec/svq3.c                             |  4 +-
 libavcodec/tdsc.c                             |  2 +-
 libavcodec/utils.c                            |  5 --
 libavcodec/vdpau.c                            |  3 -
 libavfilter/avf_showcwt.c                     |  2 +-
 libavfilter/avf_showspectrum.c                |  2 +-
 libavfilter/drawutils.c                       |  5 +-
 libavfilter/f_select.c                        |  4 +-
 libavfilter/vaf_spectrumsynth.c               |  6 +-
 libavfilter/vf_amplify.c                      |  3 -
 libavfilter/vf_atadenoise.c                   |  3 -
 libavfilter/vf_avgblur.c                      |  4 +-
 libavfilter/vf_bbox.c                         |  3 -
 libavfilter/vf_bilateral.c                    |  4 +-
 libavfilter/vf_bitplanenoise.c                |  2 -
 libavfilter/vf_blackdetect.c                  | 11 +---
 libavfilter/vf_blend.c                        |  1 -
 libavfilter/vf_blockdetect.c                  |  2 -
 libavfilter/vf_blurdetect.c                   |  2 -
 libavfilter/vf_bm3d.c                         |  3 -
 libavfilter/vf_bwdif.c                        |  2 -
 libavfilter/vf_cas.c                          |  3 -
 libavfilter/vf_chromanr.c                     |  1 -
 libavfilter/vf_chromashift.c                  |  1 -
 libavfilter/vf_colorcorrect.c                 |  1 -
 libavfilter/vf_colorize.c                     |  3 -
 libavfilter/vf_colorspace.c                   |  1 -
 libavfilter/vf_convolution.c                  |  4 +-
 libavfilter/vf_convolve.c                     |  4 +-
 libavfilter/vf_corr.c                         |  2 -
 libavfilter/vf_cover_rect.c                   |  4 +-
 libavfilter/vf_cropdetect.c                   |  6 +-
 libavfilter/vf_dblur.c                        |  4 +-
 libavfilter/vf_deband.c                       |  4 +-
 libavfilter/vf_deblock.c                      |  4 +-
 libavfilter/vf_decimate.c                     |  2 -
 libavfilter/vf_dedot.c                        |  4 +-
 libavfilter/vf_deflicker.c                    |  3 -
 libavfilter/vf_deshake.c                      |  3 +-
 libavfilter/vf_displace.c                     |  4 +-
 libavfilter/vf_drawbox.c                      |  4 +-
 libavfilter/vf_entropy.c                      |  2 -
 libavfilter/vf_estdif.c                       |  3 -
 libavfilter/vf_extractplanes.c                |  3 -
 libavfilter/vf_fade.c                         |  4 +-
 libavfilter/vf_fftdnoiz.c                     |  3 -
 libavfilter/vf_fftfilt.c                      |  4 +-
 libavfilter/vf_fieldmatch.c                   |  3 -
 libavfilter/vf_fillborders.c                  |  4 +-
 libavfilter/vf_find_rect.c                    |  2 +-
 libavfilter/vf_framepack.c                    |  3 -
 libavfilter/vf_framerate.c                    | 10 ++--
 libavfilter/vf_freezedetect.c                 |  5 +-
 libavfilter/vf_fspp.c                         |  2 -
 libavfilter/vf_gblur.c                        |  4 +-
 libavfilter/vf_guided.c                       |  4 +-
 libavfilter/vf_histogram.c                    |  8 +--
 libavfilter/vf_hqdn3d.c                       |  1 -
 libavfilter/vf_hysteresis.c                   |  4 +-
 libavfilter/vf_identity.c                     |  2 -
 libavfilter/vf_idet.c                         |  4 --
 libavfilter/vf_lagfun.c                       |  3 -
 libavfilter/vf_lenscorrection.c               |  3 -
 libavfilter/vf_limitdiff.c                    |  4 +-
 libavfilter/vf_limiter.c                      |  4 +-
 libavfilter/vf_lut.c                          |  2 -
 libavfilter/vf_lut2.c                         |  4 +-
 libavfilter/vf_maskedclamp.c                  |  4 +-
 libavfilter/vf_maskedmerge.c                  |  4 +-
 libavfilter/vf_maskedminmax.c                 |  4 +-
 libavfilter/vf_maskedthreshold.c              |  4 +-
 libavfilter/vf_maskfun.c                      |  4 +-
 libavfilter/vf_median.c                       |  4 +-
 libavfilter/vf_mestimate.c                    |  3 -
 libavfilter/vf_midequalizer.c                 |  4 +-
 libavfilter/vf_minterpolate.c                 |  3 -
 libavfilter/vf_monochrome.c                   |  3 -
 libavfilter/vf_morpho.c                       |  4 +-
 libavfilter/vf_mpdecimate.c                   |  2 -
 libavfilter/vf_negate.c                       |  2 -
 libavfilter/vf_neighbor.c                     |  4 +-
 libavfilter/vf_nlmeans.c                      |  3 -
 libavfilter/vf_nnedi.c                        |  3 -
 libavfilter/vf_ocr.c                          |  3 -
 libavfilter/vf_overlay.c                      |  6 +-
 libavfilter/vf_perspective.c                  |  1 -
 libavfilter/vf_phase.c                        |  3 -
 libavfilter/vf_pixelize.c                     |  3 -
 libavfilter/vf_pp.c                           | 12 ++--
 libavfilter/vf_pp7.c                          |  2 -
 libavfilter/vf_premultiply.c                  | 10 +---
 libavfilter/vf_psnr.c                         |  2 -
 libavfilter/vf_pullup.c                       |  4 +-
 libavfilter/vf_readeia608.c                   |  3 -
 libavfilter/vf_readvitc.c                     |  5 --
 libavfilter/vf_remap.c                        |  1 -
 libavfilter/vf_removegrain.c                  |  2 -
 libavfilter/vf_rotate.c                       |  4 +-
 libavfilter/vf_scdet.c                        |  8 +--
 libavfilter/vf_scroll.c                       |  4 +-
 libavfilter/vf_shear.c                        |  3 -
 libavfilter/vf_signalstats.c                  |  2 -
 libavfilter/vf_signature.c                    |  3 -
 libavfilter/vf_siti.c                         | 12 +---
 libavfilter/vf_spp.c                          |  2 -
 libavfilter/vf_ssim.c                         |  2 -
 libavfilter/vf_ssim360.c                      |  2 -
 libavfilter/vf_stereo3d.c                     |  5 --
 libavfilter/vf_threshold.c                    |  4 +-
 libavfilter/vf_thumbnail.c                    |  3 -
 libavfilter/vf_tinterlace.c                   | 25 +++-----
 libavfilter/vf_tmidequalizer.c                |  4 +-
 libavfilter/vf_unsharp.c                      |  4 +-
 libavfilter/vf_uspp.c                         |  2 -
 libavfilter/vf_v360.c                         |  5 --
 libavfilter/vf_vaguedenoiser.c                |  3 -
 libavfilter/vf_varblur.c                      |  4 +-
 libavfilter/vf_vectorscope.c                  | 10 ++--
 libavfilter/vf_vif.c                          |  2 -
 libavfilter/vf_w3fdif.c                       |  3 -
 libavfilter/vf_waveform.c                     |  8 +--
 libavfilter/vf_xfade.c                        |  1 -
 libavfilter/vf_xmedian.c                      |  3 -
 libavfilter/vf_yadif.c                        |  2 -
 libavfilter/vf_yaepblur.c                     |  4 +-
 libavfilter/vf_zoompan.c                      |  3 -
 libavfilter/vf_zscale.c                       |  3 -
 libavfilter/vsrc_testsrc.c                    |  2 +-
 libavformat/yuv4mpegenc.c                     | 16 -----
 libavutil/pixdesc.c                           | 60 -------------------
 libavutil/pixfmt.h                            |  5 --
 libavutil/version.h                           |  2 +-
 libswscale/utils.c                            | 20 -------
 tests/fate/lavf-image.mak                     |  2 +-
 tests/fate/pixfmt.mak                         |  4 --
 tests/fate/vcodec.mak                         | 12 ++--
 tests/ref/fate/exif-image-embedded            |  2 +-
 tests/ref/fate/exif-image-jpg                 |  2 +-
 tests/ref/fate/filter-pixfmts-copy            |  5 --
 tests/ref/fate/filter-pixfmts-crop            |  5 --
 tests/ref/fate/filter-pixfmts-field           |  5 --
 tests/ref/fate/filter-pixfmts-fieldorder      |  3 -
 tests/ref/fate/filter-pixfmts-hflip           |  5 --
 tests/ref/fate/filter-pixfmts-il              |  5 --
 tests/ref/fate/filter-pixfmts-lut             |  4 --
 tests/ref/fate/filter-pixfmts-null            |  5 --
 tests/ref/fate/filter-pixfmts-pad             |  5 --
 tests/ref/fate/filter-pixfmts-pullup          |  5 --
 tests/ref/fate/filter-pixfmts-rotate          |  2 -
 tests/ref/fate/filter-pixfmts-scale           |  5 --
 tests/ref/fate/filter-pixfmts-swapuv          |  5 --
 .../ref/fate/filter-pixfmts-tinterlace_cvlpf  |  4 --
 .../ref/fate/filter-pixfmts-tinterlace_merge  |  4 --
 tests/ref/fate/filter-pixfmts-tinterlace_pad  |  4 --
 tests/ref/fate/filter-pixfmts-tinterlace_vlpf |  4 --
 tests/ref/fate/filter-pixfmts-transpose       |  2 -
 tests/ref/fate/filter-pixfmts-vflip           |  5 --
 tests/ref/fate/imgutils                       |  5 --
 tests/ref/fate/jpg-icc                        |  2 +-
 tests/ref/fate/sws-pixdesc-query              | 15 -----
 182 files changed, 135 insertions(+), 760 deletions(-)

diff --git a/doc/APIchanges b/doc/APIchanges
index f91e855e70..1187161620 100644
--- a/doc/APIchanges
+++ b/doc/APIchanges
@@ -2,6 +2,10 @@ The last version increases of all libraries were on 2023-02-09
 
 API changes, most recent first:
 
+2023-10-xx - xxxxxxxxxx - lavu 58.28.100 - pixfmt.h
+  Remove AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P,
+  AV_PIX_FMT_YUVJ440P and AV_PIX_FMT_YUVJ411P.
+
 2023-10-xx - xxxxxxxxxx - lavc 60.23.100 - avcodec.h
   Add AVCodec.csps, AVCodec.color_ranges, AVCodec.chroma_locs, AVCodec.primaries,
   AVCodec.trcs.
diff --git a/fftools/ffmpeg_filter.c b/fftools/ffmpeg_filter.c
index 41758ac2b5..1a6cd83a03 100644
--- a/fftools/ffmpeg_filter.c
+++ b/fftools/ffmpeg_filter.c
@@ -762,30 +762,6 @@ int ofilter_bind_ost(OutputFilter *ofilter, OutputStream *ost)
             ofp->format = ost->enc_ctx->pix_fmt;
         } else {
             ofp->formats = c->pix_fmts;
-
-            // MJPEG encoder exports a full list of supported pixel formats,
-            // but the full-range ones are experimental-only.
-            // Restrict the auto-conversion list unless -strict experimental
-            // has been specified.
-            if (!strcmp(c->name, "mjpeg")) {
-                // FIXME: YUV420P etc. are actually supported with full color range,
-                // yet the latter information isn't available here.
-                static const enum AVPixelFormat mjpeg_formats[] =
-                    { AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P,
-                      AV_PIX_FMT_NONE };
-
-                const AVDictionaryEntry *strict = av_dict_get(ost->encoder_opts, "strict", NULL, 0);
-                int strict_val = ost->enc_ctx->strict_std_compliance;
-
-                if (strict) {
-                    const AVOption *o = av_opt_find(ost->enc_ctx, strict->key, NULL, 0, 0);
-                    av_assert0(o);
-                    av_opt_eval_int(ost->enc_ctx, o, strict->value, &strict_val);
-                }
-
-                if (strict_val > FF_COMPLIANCE_UNOFFICIAL)
-                    ofp->formats = mjpeg_formats;
-            }
         }
 
         fgp->disable_conversions |= ost->keep_pix_fmt;
diff --git a/libavcodec/encode.c b/libavcodec/encode.c
index f22b17f33e..59db00225f 100644
--- a/libavcodec/encode.c
+++ b/libavcodec/encode.c
@@ -603,12 +603,6 @@ static int encode_preinit_video(AVCodecContext *avctx)
 
             return AVERROR(EINVAL);
         }
-        if (c->pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||
-            c->pix_fmts[i] == AV_PIX_FMT_YUVJ411P ||
-            c->pix_fmts[i] == AV_PIX_FMT_YUVJ422P ||
-            c->pix_fmts[i] == AV_PIX_FMT_YUVJ440P ||
-            c->pix_fmts[i] == AV_PIX_FMT_YUVJ444P)
-            avctx->color_range = AVCOL_RANGE_JPEG;
     }
 
     if (c->csps) {
diff --git a/libavcodec/fraps.c b/libavcodec/fraps.c
index bed244e4e9..77f6e68e34 100644
--- a/libavcodec/fraps.c
+++ b/libavcodec/fraps.c
@@ -217,7 +217,7 @@ static int decode_frame(AVCodecContext *avctx, AVFrame *f,
     f->pict_type = AV_PICTURE_TYPE_I;
     f->flags |= AV_FRAME_FLAG_KEY;
 
-    avctx->pix_fmt = version & 1 ? is_pal ? AV_PIX_FMT_PAL8 : AV_PIX_FMT_BGR24 : AV_PIX_FMT_YUVJ420P;
+    avctx->pix_fmt = version & 1 ? is_pal ? AV_PIX_FMT_PAL8 : AV_PIX_FMT_BGR24 : AV_PIX_FMT_YUV420P;
     avctx->color_range = version & 1 ? AVCOL_RANGE_UNSPECIFIED
                                      : AVCOL_RANGE_JPEG;
     avctx->colorspace = version & 1 ? AVCOL_SPC_UNSPECIFIED : AVCOL_SPC_BT709;
diff --git a/libavcodec/h264_slice.c b/libavcodec/h264_slice.c
index 27428dea33..217b974dfb 100644
--- a/libavcodec/h264_slice.c
+++ b/libavcodec/h264_slice.c
@@ -872,15 +872,10 @@ static enum AVPixelFormat get_pixel_format(H264Context *h, int force_callback)
         if (CHROMA444(h)) {
             if (h->avctx->colorspace == AVCOL_SPC_RGB)
                 *fmt++ = AV_PIX_FMT_GBRP;
-            else if (h->avctx->color_range == AVCOL_RANGE_JPEG)
-                *fmt++ = AV_PIX_FMT_YUVJ444P;
             else
                 *fmt++ = AV_PIX_FMT_YUV444P;
         } else if (CHROMA422(h)) {
-            if (h->avctx->color_range == AVCOL_RANGE_JPEG)
-                *fmt++ = AV_PIX_FMT_YUVJ422P;
-            else
-                *fmt++ = AV_PIX_FMT_YUV422P;
+            *fmt++ = AV_PIX_FMT_YUV422P;
         } else {
 #if CONFIG_H264_DXVA2_HWACCEL
             *fmt++ = AV_PIX_FMT_DXVA2_VLD;
@@ -892,10 +887,7 @@ static enum AVPixelFormat get_pixel_format(H264Context *h, int force_callback)
 #if CONFIG_H264_VAAPI_HWACCEL
             *fmt++ = AV_PIX_FMT_VAAPI;
 #endif
-            if (h->avctx->color_range == AVCOL_RANGE_JPEG)
-                *fmt++ = AV_PIX_FMT_YUVJ420P;
-            else
-                *fmt++ = AV_PIX_FMT_YUV420P;
+            *fmt++ = AV_PIX_FMT_YUV420P;
         }
         break;
     default:
@@ -1035,17 +1027,6 @@ fail:
     return ret;
 }
 
-static enum AVPixelFormat non_j_pixfmt(enum AVPixelFormat a)
-{
-    switch (a) {
-    case AV_PIX_FMT_YUVJ420P: return AV_PIX_FMT_YUV420P;
-    case AV_PIX_FMT_YUVJ422P: return AV_PIX_FMT_YUV422P;
-    case AV_PIX_FMT_YUVJ444P: return AV_PIX_FMT_YUV444P;
-    default:
-        return a;
-    }
-}
-
 static int h264_init_ps(H264Context *h, const H264SliceContext *sl, int first_slice)
 {
     const SPS *sps;
@@ -1078,8 +1059,7 @@ static int h264_init_ps(H264Context *h, const H264SliceContext *sl, int first_sl
                      || h->mb_width  != sps->mb_width
                      || h->mb_height != sps->mb_height
                     ));
-    if (h->avctx->pix_fmt == AV_PIX_FMT_NONE
-        || (non_j_pixfmt(h->avctx->pix_fmt) != non_j_pixfmt(get_pixel_format(h, 0))))
+    if (h->avctx->pix_fmt == AV_PIX_FMT_NONE || (h->avctx->pix_fmt != get_pixel_format(h, 0)))
         must_reinit = 1;
 
     if (first_slice && av_cmp_q(sps->vui.sar, h->avctx->sample_aspect_ratio))
diff --git a/libavcodec/hevc_ps.c b/libavcodec/hevc_ps.c
index a6b64b92e3..c9d7a18f65 100644
--- a/libavcodec/hevc_ps.c
+++ b/libavcodec/hevc_ps.c
@@ -576,8 +576,6 @@ static void decode_vui(GetBitContext *gb, AVCodecContext *avctx,
     ff_h2645_decode_common_vui_params(gb, &sps->vui.common, avctx);
 
     if (vui->common.video_signal_type_present_flag) {
-        if (vui->common.video_full_range_flag && sps->pix_fmt == AV_PIX_FMT_YUV420P)
-            sps->pix_fmt = AV_PIX_FMT_YUVJ420P;
         if (vui->common.colour_description_present_flag) {
             if (vui->common.matrix_coeffs == AVCOL_SPC_RGB) {
                 switch (sps->pix_fmt) {
diff --git a/libavcodec/hevcdec.c b/libavcodec/hevcdec.c
index 55a958b41d..8ac4706622 100644
--- a/libavcodec/hevcdec.c
+++ b/libavcodec/hevcdec.c
@@ -409,7 +409,6 @@ static enum AVPixelFormat get_format(HEVCContext *s, const HEVCSPS *sps)
 
     switch (sps->pix_fmt) {
     case AV_PIX_FMT_YUV420P:
-    case AV_PIX_FMT_YUVJ420P:
 #if CONFIG_HEVC_DXVA2_HWACCEL
         *fmt++ = AV_PIX_FMT_DXVA2_VLD;
 #endif
diff --git a/libavcodec/libopenh264enc.c b/libavcodec/libopenh264enc.c
index f518d0894e..d3e7b0c746 100644
--- a/libavcodec/libopenh264enc.c
+++ b/libavcodec/libopenh264enc.c
@@ -313,10 +313,8 @@ FF_ENABLE_DEPRECATION_WARNINGS
 #if OPENH264_VER_AT_LEAST(1, 6)
     param.sSpatialLayers[0].uiVideoFormat = VF_UNDEF;
 
-    if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED) {
+    if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED)
         param.sSpatialLayers[0].bFullRange = (avctx->color_range == AVCOL_RANGE_JPEG);
-    }  else if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P)
-        param.sSpatialLayers[0].bFullRange = 1;
 
     if (avctx->colorspace != AVCOL_SPC_UNSPECIFIED      ||
         avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
@@ -447,7 +445,6 @@ const FFCodec ff_libopenh264_encoder = {
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP |
                       FF_CODEC_CAP_AUTO_THREADS,
     .p.pix_fmts     = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P,
-                                                    AV_PIX_FMT_YUVJ420P,
                                                     AV_PIX_FMT_NONE },
     .defaults       = svc_enc_defaults,
     .p.priv_class   = &class,
diff --git a/libavcodec/librav1e.c b/libavcodec/librav1e.c
index 56539435a7..dc18869e87 100644
--- a/libavcodec/librav1e.c
+++ b/libavcodec/librav1e.c
@@ -65,15 +65,8 @@ typedef struct FrameData {
     AVBufferRef *frame_opaque_ref;
 } FrameData;
 
-static inline RaPixelRange range_map(enum AVPixelFormat pix_fmt, enum AVColorRange range)
+static inline RaPixelRange range_map(enum AVColorRange range)
 {
-    switch (pix_fmt) {
-    case AV_PIX_FMT_YUVJ420P:
-    case AV_PIX_FMT_YUVJ422P:
-    case AV_PIX_FMT_YUVJ444P:
-        return RA_PIXEL_RANGE_FULL;
-    }
-
     switch (range) {
     case AVCOL_RANGE_JPEG:
         return RA_PIXEL_RANGE_FULL;
@@ -87,17 +80,14 @@ static inline RaChromaSampling pix_fmt_map(enum AVPixelFormat pix_fmt)
 {
     switch (pix_fmt) {
     case AV_PIX_FMT_YUV420P:
-    case AV_PIX_FMT_YUVJ420P:
     case AV_PIX_FMT_YUV420P10:
     case AV_PIX_FMT_YUV420P12:
         return RA_CHROMA_SAMPLING_CS420;
     case AV_PIX_FMT_YUV422P:
-    case AV_PIX_FMT_YUVJ422P:
     case AV_PIX_FMT_YUV422P10:
     case AV_PIX_FMT_YUV422P12:
         return RA_CHROMA_SAMPLING_CS422;
     case AV_PIX_FMT_YUV444P:
-    case AV_PIX_FMT_YUVJ444P:
     case AV_PIX_FMT_YUV444P10:
     case AV_PIX_FMT_YUV444P12:
         return RA_CHROMA_SAMPLING_CS444;
@@ -384,7 +374,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
     rret = rav1e_config_set_pixel_format(cfg, desc->comp[0].depth,
                                          pix_fmt_map(avctx->pix_fmt),
                                          chroma_loc_map(avctx->chroma_sample_location),
-                                         range_map(avctx->pix_fmt, avctx->color_range));
+                                         range_map(avctx->color_range));
     if (rret < 0) {
         av_log(avctx, AV_LOG_ERROR, "Failed to set pixel format properties.\n");
         ret = AVERROR_INVALIDDATA;
@@ -651,15 +641,12 @@ static const FFCodecDefault librav1e_defaults[] = {
 
 const enum AVPixelFormat librav1e_pix_fmts[] = {
     AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ420P,
     AV_PIX_FMT_YUV420P10,
     AV_PIX_FMT_YUV420P12,
     AV_PIX_FMT_YUV422P,
-    AV_PIX_FMT_YUVJ422P,
     AV_PIX_FMT_YUV422P10,
     AV_PIX_FMT_YUV422P12,
     AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV444P12,
     AV_PIX_FMT_NONE
diff --git a/libavcodec/libx264.c b/libavcodec/libx264.c
index 77a9f173b4..5bdce7b17c 100644
--- a/libavcodec/libx264.c
+++ b/libavcodec/libx264.c
@@ -805,14 +805,11 @@ static int convert_pix_fmt(enum AVPixelFormat pix_fmt)
 {
     switch (pix_fmt) {
     case AV_PIX_FMT_YUV420P:
-    case AV_PIX_FMT_YUVJ420P:
     case AV_PIX_FMT_YUV420P9:
     case AV_PIX_FMT_YUV420P10: return X264_CSP_I420;
     case AV_PIX_FMT_YUV422P:
-    case AV_PIX_FMT_YUVJ422P:
     case AV_PIX_FMT_YUV422P10: return X264_CSP_I422;
     case AV_PIX_FMT_YUV444P:
-    case AV_PIX_FMT_YUVJ444P:
     case AV_PIX_FMT_YUV444P9:
     case AV_PIX_FMT_YUV444P10: return X264_CSP_I444;
     case AV_PIX_FMT_BGR0:
@@ -1128,11 +1125,6 @@ FF_ENABLE_DEPRECATION_WARNINGS
 
     if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED)
         x4->params.vui.b_fullrange = avctx->color_range == AVCOL_RANGE_JPEG;
-    else if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
-             avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
-             avctx->pix_fmt == AV_PIX_FMT_YUVJ444P)
-        x4->params.vui.b_fullrange = 1;
-
     if (avctx->colorspace != AVCOL_SPC_UNSPECIFIED)
         x4->params.vui.i_colmatrix = avctx->colorspace;
     if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED)
@@ -1252,11 +1244,8 @@ FF_ENABLE_DEPRECATION_WARNINGS
 
 static const enum AVPixelFormat pix_fmts_8bit[] = {
     AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ420P,
     AV_PIX_FMT_YUV422P,
-    AV_PIX_FMT_YUVJ422P,
     AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_NV12,
     AV_PIX_FMT_NV16,
 #ifdef X264_CSP_NV21
@@ -1278,11 +1267,8 @@ static const enum AVPixelFormat pix_fmts_10bit[] = {
 };
 static const enum AVPixelFormat pix_fmts_all[] = {
     AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ420P,
     AV_PIX_FMT_YUV422P,
-    AV_PIX_FMT_YUVJ422P,
     AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_NV12,
     AV_PIX_FMT_NV16,
 #ifdef X264_CSP_NV21
diff --git a/libavcodec/libx265.c b/libavcodec/libx265.c
index 447e6da25f..7ffc61bdce 100644
--- a/libavcodec/libx265.c
+++ b/libavcodec/libx265.c
@@ -252,10 +252,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
             avctx->color_range == AVCOL_RANGE_JPEG;
     else
         ctx->params->vui.bEnableVideoFullRangeFlag =
-            (desc->flags & AV_PIX_FMT_FLAG_RGB) ||
-            avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
-            avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
-            avctx->pix_fmt == AV_PIX_FMT_YUVJ444P;
+            desc->flags & AV_PIX_FMT_FLAG_RGB;
 
     if ((avctx->color_primaries <= AVCOL_PRI_SMPTE432 &&
          avctx->color_primaries != AVCOL_PRI_UNSPECIFIED) ||
@@ -797,11 +794,8 @@ FF_ENABLE_DEPRECATION_WARNINGS
 
 static const enum AVPixelFormat x265_csp_eight[] = {
     AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ420P,
     AV_PIX_FMT_YUV422P,
-    AV_PIX_FMT_YUVJ422P,
     AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_GBRP,
     AV_PIX_FMT_GRAY8,
     AV_PIX_FMT_NONE
@@ -809,11 +803,8 @@ static const enum AVPixelFormat x265_csp_eight[] = {
 
 static const enum AVPixelFormat x265_csp_ten[] = {
     AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ420P,
     AV_PIX_FMT_YUV422P,
-    AV_PIX_FMT_YUVJ422P,
     AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_GBRP,
     AV_PIX_FMT_YUV420P10,
     AV_PIX_FMT_YUV422P10,
@@ -826,11 +817,8 @@ static const enum AVPixelFormat x265_csp_ten[] = {
 
 static const enum AVPixelFormat x265_csp_twelve[] = {
     AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ420P,
     AV_PIX_FMT_YUV422P,
-    AV_PIX_FMT_YUVJ422P,
     AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_GBRP,
     AV_PIX_FMT_YUV420P10,
     AV_PIX_FMT_YUV422P10,
diff --git a/libavcodec/ljpegenc.c b/libavcodec/ljpegenc.c
index aa62beac71..1b63b77829 100644
--- a/libavcodec/ljpegenc.c
+++ b/libavcodec/ljpegenc.c
@@ -325,7 +325,6 @@ const FFCodec ff_ljpeg_encoder = {
     .close          = ljpeg_encode_close,
     .p.pix_fmts     = (const enum AVPixelFormat[]){
         AV_PIX_FMT_BGR24   , AV_PIX_FMT_BGRA    , AV_PIX_FMT_BGR0,
-        AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P,
         AV_PIX_FMT_YUV420P , AV_PIX_FMT_YUV444P , AV_PIX_FMT_YUV422P,
         AV_PIX_FMT_NONE},
 };
diff --git a/libavcodec/mdec.c b/libavcodec/mdec.c
index 44b12471a9..96b5c55ba3 100644
--- a/libavcodec/mdec.c
+++ b/libavcodec/mdec.c
@@ -225,7 +225,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
     ff_permute_scantable(a->permutated_scantable, ff_zigzag_direct,
                          a->idsp.idct_permutation);
 
-    avctx->pix_fmt  = AV_PIX_FMT_YUVJ420P;
+    avctx->pix_fmt  = AV_PIX_FMT_YUV420P;
     avctx->color_range = AVCOL_RANGE_JPEG;
 
     /* init q matrix */
diff --git a/libavcodec/mjpegdec.c b/libavcodec/mjpegdec.c
index 8676155ecf..931aa137d8 100644
--- a/libavcodec/mjpegdec.c
+++ b/libavcodec/mjpegdec.c
@@ -527,7 +527,7 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
                     || s->component_id[0] == 'R' && s->component_id[1] == 'G' && s->component_id[2] == 'B') {
                     s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_GBRP : AV_PIX_FMT_GBRP16;
                 } else {
-                    if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
+                    if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_YUV444P;
                     else              s->avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
                 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
                 }
@@ -591,7 +591,7 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
                     s->component_id[1] == 'G' && s->component_id[2] == 'B') {
                 s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
             } else {
-                s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
+                s->avctx->pix_fmt = AV_PIX_FMT_YUV444P;
                 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
             }
             break;
@@ -622,7 +622,7 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
             } else {
                 if (pix_fmt_id == 0x14111100)
                     s->upscale_v[1] = s->upscale_v[2] = 1;
-                if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P;
+                if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_YUV440P;
                 else
                     goto unk_pixfmt;
                 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
@@ -635,7 +635,7 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
                     goto unk_pixfmt;
                 s->upscale_h[1] = s->upscale_h[2] = 1;
             } else {
-                if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
+                if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_YUV422P;
                 else              s->avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
                 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
             }
@@ -652,14 +652,14 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
         case 0x31111100:
             if (s->bits > 8)
                 goto unk_pixfmt;
-            s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
+            s->avctx->pix_fmt = AV_PIX_FMT_YUV444P;
             s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
             s->upscale_h[1] = s->upscale_h[2] = 2;
             break;
         case 0x22121100:
         case 0x22111200:
         case 0x41211100:
-            if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
+            if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_YUV422P;
             else
                 goto unk_pixfmt;
             s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
@@ -668,7 +668,7 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
         case 0x23111100:
         case 0x42111100:
         case 0x24111100:
-            if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;
+            if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_YUV420P;
             else              s->avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
             s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
             if (pix_fmt_id == 0x42111100) {
@@ -686,7 +686,7 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
             }
             break;
         case 0x41111100:
-            if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV411P : AV_PIX_FMT_YUVJ411P;
+            if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_YUV411P;
             else
                 goto unk_pixfmt;
             s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
@@ -2625,14 +2625,10 @@ the_end:
 
     if (AV_RB32(s->upscale_h)) {
         int p;
-        av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
-                   avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||
-                   avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
+        av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||
                    avctx->pix_fmt == AV_PIX_FMT_YUV440P  ||
                    avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
-                   avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
                    avctx->pix_fmt == AV_PIX_FMT_YUV422P  ||
-                   avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
                    avctx->pix_fmt == AV_PIX_FMT_YUV420P  ||
                    avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
                    avctx->pix_fmt == AV_PIX_FMT_YUVA420P  ||
@@ -2706,14 +2702,10 @@ the_end:
     }
     if (AV_RB32(s->upscale_v)) {
         int p;
-        av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
-                   avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||
-                   avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
+        av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUV444P  ||
                    avctx->pix_fmt == AV_PIX_FMT_YUV422P  ||
-                   avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
                    avctx->pix_fmt == AV_PIX_FMT_YUV420P  ||
                    avctx->pix_fmt == AV_PIX_FMT_YUV440P  ||
-                   avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
                    avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
                    avctx->pix_fmt == AV_PIX_FMT_YUVA420P  ||
                    avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
diff --git a/libavcodec/mjpegenc.c b/libavcodec/mjpegenc.c
index c827a47e59..55fd250b35 100644
--- a/libavcodec/mjpegenc.c
+++ b/libavcodec/mjpegenc.c
@@ -655,7 +655,6 @@ const FFCodec ff_mjpeg_encoder = {
                       AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_ICC_PROFILES,
     .p.pix_fmts     = (const enum AVPixelFormat[]) {
-        AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P,
         AV_PIX_FMT_YUV420P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV444P,
         AV_PIX_FMT_NONE
     },
@@ -683,7 +682,7 @@ const FFCodec ff_amv_encoder = {
     .close          = mjpeg_encode_close,
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
     .p.pix_fmts     = (const enum AVPixelFormat[]) {
-        AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_NONE
+        AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
     },
     .p.color_ranges = (const enum AVColorRange[]) {
         AVCOL_RANGE_JPEG, AVCOL_RANGE_UNSPECIFIED
diff --git a/libavcodec/mjpegenc_common.c b/libavcodec/mjpegenc_common.c
index 049ae3d929..7b5ca29b34 100644
--- a/libavcodec/mjpegenc_common.c
+++ b/libavcodec/mjpegenc_common.c
@@ -257,7 +257,7 @@ void ff_mjpeg_init_hvsample(AVCodecContext *avctx, int hsample[4], int vsample[4
         vsample[1] = hsample[1] =
         vsample[2] = hsample[2] =
         vsample[3] = hsample[3] = 1;
-    } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P || avctx->pix_fmt == AV_PIX_FMT_YUVJ444P) {
+    } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P) {
         vsample[0] = vsample[1] = vsample[2] = 2;
         hsample[0] = hsample[1] = hsample[2] = 1;
     } else {
diff --git a/libavcodec/mpegvideo_enc.c b/libavcodec/mpegvideo_enc.c
index 19174aa33c..600553dd00 100644
--- a/libavcodec/mpegvideo_enc.c
+++ b/libavcodec/mpegvideo_enc.c
@@ -317,15 +317,12 @@ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
     mpv_encode_defaults(s);
 
     switch (avctx->pix_fmt) {
-    case AV_PIX_FMT_YUVJ444P:
     case AV_PIX_FMT_YUV444P:
         s->chroma_format = CHROMA_444;
         break;
-    case AV_PIX_FMT_YUVJ422P:
     case AV_PIX_FMT_YUV422P:
         s->chroma_format = CHROMA_422;
         break;
-    case AV_PIX_FMT_YUVJ420P:
     case AV_PIX_FMT_YUV420P:
     default:
         s->chroma_format = CHROMA_420;
diff --git a/libavcodec/nvenc.c b/libavcodec/nvenc.c
index 626f10d20a..498e9e06fe 100644
--- a/libavcodec/nvenc.c
+++ b/libavcodec/nvenc.c
@@ -1163,8 +1163,7 @@ static av_cold int nvenc_setup_h264_config(AVCodecContext *avctx)
         vui->colourMatrix = IS_GBRP(ctx->data_pix_fmt) ? AVCOL_SPC_RGB : avctx->colorspace;
         vui->colourPrimaries = avctx->color_primaries;
         vui->transferCharacteristics = avctx->color_trc;
-        vui->videoFullRangeFlag = (avctx->color_range == AVCOL_RANGE_JPEG
-            || ctx->data_pix_fmt == AV_PIX_FMT_YUVJ420P || ctx->data_pix_fmt == AV_PIX_FMT_YUVJ422P || ctx->data_pix_fmt == AV_PIX_FMT_YUVJ444P);
+        vui->videoFullRangeFlag = avctx->color_range == AVCOL_RANGE_JPEG;
     }
 
     vui->colourDescriptionPresentFlag =
@@ -1289,8 +1288,7 @@ static av_cold int nvenc_setup_hevc_config(AVCodecContext *avctx)
         vui->colourMatrix = IS_GBRP(ctx->data_pix_fmt) ? AVCOL_SPC_RGB : avctx->colorspace;
         vui->colourPrimaries = avctx->color_primaries;
         vui->transferCharacteristics = avctx->color_trc;
-        vui->videoFullRangeFlag = (avctx->color_range == AVCOL_RANGE_JPEG
-            || ctx->data_pix_fmt == AV_PIX_FMT_YUVJ420P || ctx->data_pix_fmt == AV_PIX_FMT_YUVJ422P || ctx->data_pix_fmt == AV_PIX_FMT_YUVJ444P);
+        vui->videoFullRangeFlag = avctx->color_range == AVCOL_RANGE_JPEG;
     }
 
     vui->colourDescriptionPresentFlag =
@@ -1407,8 +1405,7 @@ static av_cold int nvenc_setup_av1_config(AVCodecContext *avctx)
         av1->matrixCoefficients = IS_GBRP(ctx->data_pix_fmt) ? AVCOL_SPC_RGB : avctx->colorspace;
         av1->colorPrimaries = avctx->color_primaries;
         av1->transferCharacteristics = avctx->color_trc;
-        av1->colorRange = (avctx->color_range == AVCOL_RANGE_JPEG
-            || ctx->data_pix_fmt == AV_PIX_FMT_YUVJ420P || ctx->data_pix_fmt == AV_PIX_FMT_YUVJ422P || ctx->data_pix_fmt == AV_PIX_FMT_YUVJ444P);
+        av1->colorRange = avctx->color_range == AVCOL_RANGE_JPEG;
     }
 
     if (IS_YUV444(ctx->data_pix_fmt)) {
diff --git a/libavcodec/qsv.c b/libavcodec/qsv.c
index 7563625627..540c766db5 100644
--- a/libavcodec/qsv.c
+++ b/libavcodec/qsv.c
@@ -225,7 +225,6 @@ int ff_qsv_map_pixfmt(enum AVPixelFormat format, uint32_t *fourcc, uint16_t *shi
 {
     switch (format) {
     case AV_PIX_FMT_YUV420P:
-    case AV_PIX_FMT_YUVJ420P:
     case AV_PIX_FMT_NV12:
         *fourcc = MFX_FOURCC_NV12;
         *shift = 0;
diff --git a/libavcodec/raw.c b/libavcodec/raw.c
index b73b80e5fd..478b4e38b7 100644
--- a/libavcodec/raw.c
+++ b/libavcodec/raw.c
@@ -39,13 +39,6 @@ static const PixelFormatTag raw_pix_fmt_tags[] = {
     { AV_PIX_FMT_YUV422P, MKTAG('Y', '4', '2', 'B') },
     { AV_PIX_FMT_YUV422P, MKTAG('P', '4', '2', '2') },
     { AV_PIX_FMT_YUV422P, MKTAG('Y', 'V', '1', '6') },
-    /* yuvjXXX formats are deprecated hacks specific to libav*,
-       they are identical to yuvXXX  */
-    { AV_PIX_FMT_YUVJ420P, MKTAG('I', '4', '2', '0') }, /* Planar formats */
-    { AV_PIX_FMT_YUVJ420P, MKTAG('I', 'Y', 'U', 'V') },
-    { AV_PIX_FMT_YUVJ420P, MKTAG('Y', 'V', '1', '2') },
-    { AV_PIX_FMT_YUVJ422P, MKTAG('Y', '4', '2', 'B') },
-    { AV_PIX_FMT_YUVJ422P, MKTAG('P', '4', '2', '2') },
     { AV_PIX_FMT_GRAY8,    MKTAG('Y', '8', '0', '0') },
     { AV_PIX_FMT_GRAY8,    MKTAG('Y', '8', ' ', ' ') },
 
@@ -103,11 +96,8 @@ static const PixelFormatTag raw_pix_fmt_tags[] = {
     { AV_PIX_FMT_BGR24,    MKTAG('B', 'G', 'R', 24 ) },
     { AV_PIX_FMT_YUV411P,  MKTAG('4', '1', '1', 'P') },
     { AV_PIX_FMT_YUV422P,  MKTAG('4', '2', '2', 'P') },
-    { AV_PIX_FMT_YUVJ422P, MKTAG('4', '2', '2', 'P') },
     { AV_PIX_FMT_YUV440P,  MKTAG('4', '4', '0', 'P') },
-    { AV_PIX_FMT_YUVJ440P, MKTAG('4', '4', '0', 'P') },
     { AV_PIX_FMT_YUV444P,  MKTAG('4', '4', '4', 'P') },
-    { AV_PIX_FMT_YUVJ444P, MKTAG('4', '4', '4', 'P') },
     { AV_PIX_FMT_MONOWHITE,MKTAG('B', '1', 'W', '0') },
     { AV_PIX_FMT_MONOBLACK,MKTAG('B', '0', 'W', '1') },
     { AV_PIX_FMT_BGR8,     MKTAG('B', 'G', 'R',  8 ) },
@@ -257,10 +247,6 @@ static const PixelFormatTag raw_pix_fmt_tags[] = {
     { AV_PIX_FMT_YUV422P,     MKTAG('I', '4', '2', '2') },
     { AV_PIX_FMT_YUV440P,     MKTAG('I', '4', '4', '0') },
     { AV_PIX_FMT_YUV444P,     MKTAG('I', '4', '4', '4') },
-    { AV_PIX_FMT_YUVJ420P,    MKTAG('J', '4', '2', '0') },
-    { AV_PIX_FMT_YUVJ422P,    MKTAG('J', '4', '2', '2') },
-    { AV_PIX_FMT_YUVJ440P,    MKTAG('J', '4', '4', '0') },
-    { AV_PIX_FMT_YUVJ444P,    MKTAG('J', '4', '4', '4') },
     { AV_PIX_FMT_YUVA444P,    MKTAG('Y', 'U', 'V', 'A') },
     { AV_PIX_FMT_YUVA420P,    MKTAG('I', '4', '0', 'A') },
     { AV_PIX_FMT_YUVA422P,    MKTAG('I', '4', '2', 'A') },
diff --git a/libavcodec/roqvideodec.c b/libavcodec/roqvideodec.c
index bfc69a65c9..50e14934b6 100644
--- a/libavcodec/roqvideodec.c
+++ b/libavcodec/roqvideodec.c
@@ -184,7 +184,7 @@ static av_cold int roq_decode_init(AVCodecContext *avctx)
     if (!s->current_frame || !s->last_frame)
         return AVERROR(ENOMEM);
 
-    avctx->pix_fmt = AV_PIX_FMT_YUVJ444P;
+    avctx->pix_fmt = AV_PIX_FMT_YUV444P;
     avctx->color_range = AVCOL_RANGE_JPEG;
 
     return 0;
diff --git a/libavcodec/roqvideoenc.c b/libavcodec/roqvideoenc.c
index b584ee1142..3cc4ddaa8b 100644
--- a/libavcodec/roqvideoenc.c
+++ b/libavcodec/roqvideoenc.c
@@ -1125,7 +1125,7 @@ const FFCodec ff_roq_encoder = {
     .init                 = roq_encode_init,
     FF_CODEC_ENCODE_CB(roq_encode_frame),
     .close                = roq_encode_end,
-    .p.pix_fmts           = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUVJ444P,
+    .p.pix_fmts           = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV444P,
                                                         AV_PIX_FMT_NONE },
     .p.color_ranges       = (const enum AVColorRange[]){ AVCOL_RANGE_JPEG,
                                                         AVCOL_RANGE_UNSPECIFIED },
diff --git a/libavcodec/svq3.c b/libavcodec/svq3.c
index 2d03dbc457..9217c60182 100644
--- a/libavcodec/svq3.c
+++ b/libavcodec/svq3.c
@@ -1143,7 +1143,7 @@ static av_cold int svq3_decode_init(AVCodecContext *avctx)
     ff_hpeldsp_init(&s->hdsp, avctx->flags);
     ff_tpeldsp_init(&s->tdsp);
 
-    avctx->pix_fmt     = AV_PIX_FMT_YUVJ420P;
+    avctx->pix_fmt     = AV_PIX_FMT_YUV420P;
     avctx->color_range = AVCOL_RANGE_JPEG;
 
     s->avctx         = avctx;
@@ -1602,7 +1602,7 @@ const FFCodec ff_svq3_decoder = {
     .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND |
                       AV_CODEC_CAP_DR1             |
                       AV_CODEC_CAP_DELAY,
-    .p.pix_fmts     = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
+    .p.pix_fmts     = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
                                                      AV_PIX_FMT_NONE},
     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
 };
diff --git a/libavcodec/tdsc.c b/libavcodec/tdsc.c
index 739738d9b1..d4f5953524 100644
--- a/libavcodec/tdsc.c
+++ b/libavcodec/tdsc.c
@@ -360,7 +360,7 @@ static int tdsc_decode_jpeg_tile(AVCodecContext *avctx, int tile_size,
     }
 
     ret = avcodec_receive_frame(ctx->jpeg_avctx, ctx->jpgframe);
-    if (ret < 0 || ctx->jpgframe->format != AV_PIX_FMT_YUVJ420P) {
+    if (ret < 0 || ctx->jpgframe->format != AV_PIX_FMT_YUV420P) {
         av_log(avctx, AV_LOG_ERROR,
                "JPEG decoding error (%d).\n", ret);
 
diff --git a/libavcodec/utils.c b/libavcodec/utils.c
index e7af60be98..a458259bd2 100644
--- a/libavcodec/utils.c
+++ b/libavcodec/utils.c
@@ -167,10 +167,6 @@ void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
     case AV_PIX_FMT_GRAY8:
     case AV_PIX_FMT_GRAY16BE:
     case AV_PIX_FMT_GRAY16LE:
-    case AV_PIX_FMT_YUVJ420P:
-    case AV_PIX_FMT_YUVJ422P:
-    case AV_PIX_FMT_YUVJ440P:
-    case AV_PIX_FMT_YUVJ444P:
     case AV_PIX_FMT_YUVA420P:
     case AV_PIX_FMT_YUVA422P:
     case AV_PIX_FMT_YUVA444P:
@@ -250,7 +246,6 @@ void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
             w_align = 16*2;
         break;
     case AV_PIX_FMT_YUV411P:
-    case AV_PIX_FMT_YUVJ411P:
     case AV_PIX_FMT_UYYVYY411:
         w_align = 32;
         h_align = 16 * 2;
diff --git a/libavcodec/vdpau.c b/libavcodec/vdpau.c
index 2b9b78d8d0..680e0784cc 100644
--- a/libavcodec/vdpau.c
+++ b/libavcodec/vdpau.c
@@ -88,7 +88,6 @@ int av_vdpau_get_surface_parameters(AVCodecContext *avctx,
     /* See <vdpau/vdpau.h> for per-type alignment constraints. */
     switch (avctx->sw_pix_fmt) {
     case AV_PIX_FMT_YUV420P:
-    case AV_PIX_FMT_YUVJ420P:
     case AV_PIX_FMT_YUV420P10:
     case AV_PIX_FMT_YUV420P12:
         t = VDP_CHROMA_TYPE_420;
@@ -96,13 +95,11 @@ int av_vdpau_get_surface_parameters(AVCodecContext *avctx,
         h = (h + 3) & ~3;
         break;
     case AV_PIX_FMT_YUV422P:
-    case AV_PIX_FMT_YUVJ422P:
         t = VDP_CHROMA_TYPE_422;
         w = (w + 1) & ~1;
         h = (h + 1) & ~1;
         break;
     case AV_PIX_FMT_YUV444P:
-    case AV_PIX_FMT_YUVJ444P:
     case AV_PIX_FMT_YUV444P10:
     case AV_PIX_FMT_YUV444P12:
         t = VDP_CHROMA_TYPE_444;
diff --git a/libavfilter/avf_showcwt.c b/libavfilter/avf_showcwt.c
index d5bc920a4b..9753d9212e 100644
--- a/libavfilter/avf_showcwt.c
+++ b/libavfilter/avf_showcwt.c
@@ -228,7 +228,7 @@ static int query_formats(AVFilterContext *ctx)
     AVFilterLink *inlink = ctx->inputs[0];
     AVFilterLink *outlink = ctx->outputs[0];
     static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE };
-    static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVA444P, AV_PIX_FMT_NONE };
+    static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P, AV_PIX_FMT_NONE };
     int ret;
 
     formats = ff_make_format_list(sample_fmts);
diff --git a/libavfilter/avf_showspectrum.c b/libavfilter/avf_showspectrum.c
index 8cf73fce70..530f98e023 100644
--- a/libavfilter/avf_showspectrum.c
+++ b/libavfilter/avf_showspectrum.c
@@ -365,7 +365,7 @@ static int query_formats(AVFilterContext *ctx)
     AVFilterLink *inlink = ctx->inputs[0];
     AVFilterLink *outlink = ctx->outputs[0];
     static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE };
-    static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVA444P, AV_PIX_FMT_NONE };
+    static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P, AV_PIX_FMT_NONE };
     int ret;
 
     /* set input audio formats */
diff --git a/libavfilter/drawutils.c b/libavfilter/drawutils.c
index 1081938d86..d5ee122c1f 100644
--- a/libavfilter/drawutils.c
+++ b/libavfilter/drawutils.c
@@ -98,10 +98,7 @@ int ff_draw_init2(FFDrawContext *draw, enum AVPixelFormat format, enum AVColorSp
     if (!(desc->flags & AV_PIX_FMT_FLAG_RGB) && !(luma = av_csp_luma_coeffs_from_avcsp(csp)))
         return AVERROR(EINVAL);
     if (range == AVCOL_RANGE_UNSPECIFIED)
-        range = (format == AV_PIX_FMT_YUVJ420P || format == AV_PIX_FMT_YUVJ422P ||
-                 format == AV_PIX_FMT_YUVJ444P || format == AV_PIX_FMT_YUVJ411P ||
-                 format == AV_PIX_FMT_YUVJ440P || csp == AVCOL_SPC_RGB)
-                ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
+        range = csp == AVCOL_SPC_RGB ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
     if (range != AVCOL_RANGE_JPEG && range != AVCOL_RANGE_MPEG)
         return AVERROR(EINVAL);
     for (i = 0; i < desc->nb_components; i++) {
diff --git a/libavfilter/f_select.c b/libavfilter/f_select.c
index 47e36f0014..7f082ffb29 100644
--- a/libavfilter/f_select.c
+++ b/libavfilter/f_select.c
@@ -502,9 +502,7 @@ static int query_formats(AVFilterContext *ctx)
         static const enum AVPixelFormat pix_fmts[] = {
             AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24, AV_PIX_FMT_RGBA,
             AV_PIX_FMT_ABGR, AV_PIX_FMT_BGRA, AV_PIX_FMT_GRAY8,
-            AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P,
-            AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVJ422P,
-            AV_PIX_FMT_YUV420P10,
+            AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P10,
             AV_PIX_FMT_NONE
         };
         return ff_set_common_formats_from_list(ctx, pix_fmts);
diff --git a/libavfilter/vaf_spectrumsynth.c b/libavfilter/vaf_spectrumsynth.c
index 896eba558e..2b0f277f5c 100644
--- a/libavfilter/vaf_spectrumsynth.c
+++ b/libavfilter/vaf_spectrumsynth.c
@@ -106,8 +106,8 @@ static int query_formats(AVFilterContext *ctx)
     AVFilterLink *outlink = ctx->outputs[0];
     static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE };
     static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16,
-                                                   AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
-                                                   AV_PIX_FMT_YUV444P16, AV_PIX_FMT_NONE };
+                                                   AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV444P16,
+                                                   AV_PIX_FMT_NONE };
     int ret, sample_rates[] = { 48000, -1 };
 
     formats = ff_make_format_list(sample_fmts);
@@ -293,7 +293,6 @@ static void read_fft_data(AVFilterContext *ctx, int x, int h, int ch)
                 read16_fft_bin(s, x, y, f, ch);
             }
             break;
-        case AV_PIX_FMT_YUVJ444P:
         case AV_PIX_FMT_YUV444P:
         case AV_PIX_FMT_GRAY8:
             for (y = start, f = 0; y >= end; y--, f++) {
@@ -310,7 +309,6 @@ static void read_fft_data(AVFilterContext *ctx, int x, int h, int ch)
                 read16_fft_bin(s, y, x, f, ch);
             }
             break;
-        case AV_PIX_FMT_YUVJ444P:
         case AV_PIX_FMT_YUV444P:
         case AV_PIX_FMT_GRAY8:
             for (y = end, f = 0; y <= start; y++, f++) {
diff --git a/libavfilter/vf_amplify.c b/libavfilter/vf_amplify.c
index 0ebca60ea2..9e1910951b 100644
--- a/libavfilter/vf_amplify.c
+++ b/libavfilter/vf_amplify.c
@@ -55,9 +55,6 @@ static const enum AVPixelFormat pixel_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_atadenoise.c b/libavfilter/vf_atadenoise.c
index eed12acfa4..36a9dcefda 100644
--- a/libavfilter/vf_atadenoise.c
+++ b/libavfilter/vf_atadenoise.c
@@ -99,9 +99,6 @@ static const enum AVPixelFormat pixel_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_avgblur.c b/libavfilter/vf_avgblur.c
index 8ff6111bcc..ce7dd5a306 100644
--- a/libavfilter/vf_avgblur.c
+++ b/libavfilter/vf_avgblur.c
@@ -247,10 +247,8 @@ static void averageiir2d(AVFilterContext *ctx, AVFrame *in, AVFrame *out, int pl
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_bbox.c b/libavfilter/vf_bbox.c
index 02893d500d..b382d1ccf5 100644
--- a/libavfilter/vf_bbox.c
+++ b/libavfilter/vf_bbox.c
@@ -53,9 +53,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_bilateral.c b/libavfilter/vf_bilateral.c
index fe16419026..2291501291 100644
--- a/libavfilter/vf_bilateral.c
+++ b/libavfilter/vf_bilateral.c
@@ -68,10 +68,8 @@ AVFILTER_DEFINE_CLASS(bilateral);
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_bitplanenoise.c b/libavfilter/vf_bitplanenoise.c
index 32235ff230..e1388d3e99 100644
--- a/libavfilter/vf_bitplanenoise.c
+++ b/libavfilter/vf_bitplanenoise.c
@@ -49,8 +49,6 @@ AVFILTER_DEFINE_CLASS(bitplanenoise);
 static const enum AVPixelFormat pixfmts[] = {
     AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P,
-    AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV420P9,
     AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV420P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_blackdetect.c b/libavfilter/vf_blackdetect.c
index 55033ba5ea..98c0e2a107 100644
--- a/libavfilter/vf_blackdetect.c
+++ b/libavfilter/vf_blackdetect.c
@@ -67,20 +67,12 @@ static const AVOption blackdetect_options[] = {
 
 AVFILTER_DEFINE_CLASS(blackdetect);
 
-#define YUVJ_FORMATS \
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P
-
-static const enum AVPixelFormat yuvj_formats[] = {
-    YUVJ_FORMATS, AV_PIX_FMT_NONE
-};
-
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_GRAY8,
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
     AV_PIX_FMT_NV12, AV_PIX_FMT_NV21,
-    YUVJ_FORMATS,
     AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14,
     AV_PIX_FMT_GRAY16,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
@@ -177,8 +169,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *picref)
     double picture_black_ratio = 0;
     const int max = (1 << s->depth) - 1;
     const int factor = (1 << (s->depth - 8));
-    const int full = picref->color_range == AVCOL_RANGE_JPEG ||
-                     ff_fmt_is_in(picref->format, yuvj_formats);
+    const int full = picref->color_range == AVCOL_RANGE_JPEG;
 
     s->pixel_black_th_i = full ? s->pixel_black_th * max :
         // luminance_minimum_value + pixel_black_th * luminance_range_size
diff --git a/libavfilter/vf_blend.c b/libavfilter/vf_blend.c
index 7100d9f372..6d19e3a928 100644
--- a/libavfilter/vf_blend.c
+++ b/libavfilter/vf_blend.c
@@ -253,7 +253,6 @@ static av_cold int init(AVFilterContext *ctx)
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ422P,AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_GRAY8,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
diff --git a/libavfilter/vf_blockdetect.c b/libavfilter/vf_blockdetect.c
index d787aff5e4..a7b8902b1a 100644
--- a/libavfilter/vf_blockdetect.c
+++ b/libavfilter/vf_blockdetect.c
@@ -258,8 +258,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV420P,
     AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV440P,
     AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV410P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
     AV_PIX_FMT_NONE
 };
diff --git a/libavfilter/vf_blurdetect.c b/libavfilter/vf_blurdetect.c
index 354a6b6100..5f7b1f89eb 100644
--- a/libavfilter/vf_blurdetect.c
+++ b/libavfilter/vf_blurdetect.c
@@ -342,8 +342,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV420P,
     AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV440P,
     AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV410P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
     AV_PIX_FMT_NONE
 };
diff --git a/libavfilter/vf_bm3d.c b/libavfilter/vf_bm3d.c
index cdced50ba3..9be1faba8e 100644
--- a/libavfilter/vf_bm3d.c
+++ b/libavfilter/vf_bm3d.c
@@ -169,9 +169,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_bwdif.c b/libavfilter/vf_bwdif.c
index 137cd5ef13..17f33207be 100644
--- a/libavfilter/vf_bwdif.c
+++ b/libavfilter/vf_bwdif.c
@@ -151,8 +151,6 @@ static av_cold void uninit(AVFilterContext *ctx)
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV420P,
     AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
diff --git a/libavfilter/vf_cas.c b/libavfilter/vf_cas.c
index 5fa5055d76..b99250d797 100644
--- a/libavfilter/vf_cas.c
+++ b/libavfilter/vf_cas.c
@@ -207,9 +207,6 @@ static const enum AVPixelFormat pixel_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_chromanr.c b/libavfilter/vf_chromanr.c
index dd49d8670a..0f4a27add5 100644
--- a/libavfilter/vf_chromanr.c
+++ b/libavfilter/vf_chromanr.c
@@ -57,7 +57,6 @@ typedef struct ChromaNRContext {
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV444P,
     AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV420P9,   AV_PIX_FMT_YUV422P9,   AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10,  AV_PIX_FMT_YUV422P10,  AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV444P12,  AV_PIX_FMT_YUV422P12,  AV_PIX_FMT_YUV440P12, AV_PIX_FMT_YUV420P12,
diff --git a/libavfilter/vf_chromashift.c b/libavfilter/vf_chromashift.c
index 39b96a749e..06e3053ccc 100644
--- a/libavfilter/vf_chromashift.c
+++ b/libavfilter/vf_chromashift.c
@@ -380,7 +380,6 @@ static const AVFilterPad inputs[] = {
 
 static const enum AVPixelFormat yuv_pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ422P,AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_colorcorrect.c b/libavfilter/vf_colorcorrect.c
index 1c4dea531b..b23ede296d 100644
--- a/libavfilter/vf_colorcorrect.c
+++ b/libavfilter/vf_colorcorrect.c
@@ -430,7 +430,6 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
 static const enum AVPixelFormat pixel_fmts[] = {
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV444P,
     AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV420P9,   AV_PIX_FMT_YUV422P9,   AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10,  AV_PIX_FMT_YUV422P10,  AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV444P12,  AV_PIX_FMT_YUV422P12,  AV_PIX_FMT_YUV440P12, AV_PIX_FMT_YUV420P12,
diff --git a/libavfilter/vf_colorize.c b/libavfilter/vf_colorize.c
index e6c563e3e2..236b53a6c5 100644
--- a/libavfilter/vf_colorize.c
+++ b/libavfilter/vf_colorize.c
@@ -212,9 +212,6 @@ static const enum AVPixelFormat pixel_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_colorspace.c b/libavfilter/vf_colorspace.c
index 5ab5266ef0..8906203d60 100644
--- a/libavfilter/vf_colorspace.c
+++ b/libavfilter/vf_colorspace.c
@@ -824,7 +824,6 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_YUV420P,   AV_PIX_FMT_YUV422P,   AV_PIX_FMT_YUV444P,
         AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
         AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
-        AV_PIX_FMT_YUVJ420P,  AV_PIX_FMT_YUVJ422P,  AV_PIX_FMT_YUVJ444P,
         AV_PIX_FMT_NONE
     };
     int res;
diff --git a/libavfilter/vf_convolution.c b/libavfilter/vf_convolution.c
index c1a63c9aa9..ee46b42099 100644
--- a/libavfilter/vf_convolution.c
+++ b/libavfilter/vf_convolution.c
@@ -80,10 +80,8 @@ static const int same7x7[49] = {0, 0, 0, 0, 0, 0, 0,
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_convolve.c b/libavfilter/vf_convolve.c
index 3246868888..f7a6f6ced2 100644
--- a/libavfilter/vf_convolve.c
+++ b/libavfilter/vf_convolve.c
@@ -92,10 +92,8 @@ static const AVOption convolve_options[] = {
 
 static const enum AVPixelFormat pixel_fmts_fftfilt[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_corr.c b/libavfilter/vf_corr.c
index fb2770539e..7fd1b313fa 100644
--- a/libavfilter/vf_corr.c
+++ b/libavfilter/vf_corr.c
@@ -191,8 +191,6 @@ static const enum AVPixelFormat pix_fmts[] = {
 #define PF(suf)         PF_NOALPHA(suf), PF_ALPHA(suf)
     PF(P), PF(P9), PF(P10), PF_NOALPHA(P12), PF_NOALPHA(P14), PF(P16),
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
     AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
     AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
diff --git a/libavfilter/vf_cover_rect.c b/libavfilter/vf_cover_rect.c
index 7f34311589..12b821b9a4 100644
--- a/libavfilter/vf_cover_rect.c
+++ b/libavfilter/vf_cover_rect.c
@@ -215,7 +215,7 @@ static av_cold int init(AVFilterContext *ctx)
                                 &cover->cover_frame->format, cover->cover_filename, ctx)) < 0)
             return ret;
 
-        if (cover->cover_frame->format != AV_PIX_FMT_YUV420P && cover->cover_frame->format != AV_PIX_FMT_YUVJ420P) {
+        if (cover->cover_frame->format != AV_PIX_FMT_YUV420P) {
             av_log(ctx, AV_LOG_ERROR, "cover image is not a YUV420 image\n");
             return AVERROR(EINVAL);
         }
@@ -241,6 +241,6 @@ const AVFilter ff_vf_cover_rect = {
     .uninit          = uninit,
     FILTER_INPUTS(cover_rect_inputs),
     FILTER_OUTPUTS(ff_video_default_filterpad),
-    FILTER_PIXFMTS(AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P),
+    FILTER_PIXFMTS(AV_PIX_FMT_YUV420P),
     .priv_class      = &cover_rect_class,
 };
diff --git a/libavfilter/vf_cropdetect.c b/libavfilter/vf_cropdetect.c
index 58755fc356..08740e50a7 100644
--- a/libavfilter/vf_cropdetect.c
+++ b/libavfilter/vf_cropdetect.c
@@ -59,9 +59,9 @@ typedef struct CropDetectContext {
 } CropDetectContext;
 
 static const enum AVPixelFormat pix_fmts[] = {
-    AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
+    AV_PIX_FMT_YUV420P,
+    AV_PIX_FMT_YUV422P,
+    AV_PIX_FMT_YUV444P,
     AV_PIX_FMT_YUV411P, AV_PIX_FMT_GRAY8,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9 , AV_PIX_FMT_YUV422P9 , AV_PIX_FMT_YUV444P9,
diff --git a/libavfilter/vf_dblur.c b/libavfilter/vf_dblur.c
index 3110d19271..6ee6ece03c 100644
--- a/libavfilter/vf_dblur.c
+++ b/libavfilter/vf_dblur.c
@@ -113,10 +113,8 @@ static void diriir2d(AVFilterContext *ctx, int plane)
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_deband.c b/libavfilter/vf_deband.c
index 177d888bed..befc7df2da 100644
--- a/libavfilter/vf_deband.c
+++ b/libavfilter/vf_deband.c
@@ -79,8 +79,6 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16,
         AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV420P,
         AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV410P,  AV_PIX_FMT_YUV440P,
-        AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-        AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ440P,
         AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
         AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
         AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
@@ -97,7 +95,7 @@ static int query_formats(AVFilterContext *ctx)
     };
 
     static const enum AVPixelFormat cpix_fmts[] = {
-        AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
+        AV_PIX_FMT_YUV444P,
         AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P9,
         AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA444P10,
         AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV444P14,
diff --git a/libavfilter/vf_deblock.c b/libavfilter/vf_deblock.c
index d35b22e3be..3bdd3ec075 100644
--- a/libavfilter/vf_deblock.c
+++ b/libavfilter/vf_deblock.c
@@ -62,10 +62,8 @@ typedef struct DeblockContext {
 
 static const enum AVPixelFormat pixel_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_decimate.c b/libavfilter/vf_decimate.c
index dbeca427f1..8651f976cb 100644
--- a/libavfilter/vf_decimate.c
+++ b/libavfilter/vf_decimate.c
@@ -372,8 +372,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     PF(P), PF(P9), PF(P10), PF_NOALPHA(P12), PF_NOALPHA(P14), PF(P16),
     AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV440P12,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14,
     AV_PIX_FMT_GRAY16,
     AV_PIX_FMT_NONE
diff --git a/libavfilter/vf_dedot.c b/libavfilter/vf_dedot.c
index 7aa2583184..b52338f11a 100644
--- a/libavfilter/vf_dedot.c
+++ b/libavfilter/vf_dedot.c
@@ -56,10 +56,8 @@ typedef struct DedotContext {
 
 static const enum AVPixelFormat pixel_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_deflicker.c b/libavfilter/vf_deflicker.c
index 25172135ed..4146385b33 100644
--- a/libavfilter/vf_deflicker.c
+++ b/libavfilter/vf_deflicker.c
@@ -96,9 +96,6 @@ static const enum AVPixelFormat pixel_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_deshake.c b/libavfilter/vf_deshake.c
index d44dd71eb0..fbb4451d6a 100644
--- a/libavfilter/vf_deshake.c
+++ b/libavfilter/vf_deshake.c
@@ -375,8 +375,7 @@ static av_cold int init(AVFilterContext *ctx)
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV420P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV410P,
-    AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV440P,  AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_NONE
+    AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV440P,  AV_PIX_FMT_NONE
 };
 
 static int config_props(AVFilterLink *link)
diff --git a/libavfilter/vf_displace.c b/libavfilter/vf_displace.c
index 8cc11f07ba..3890b6bc27 100644
--- a/libavfilter/vf_displace.c
+++ b/libavfilter/vf_displace.c
@@ -62,10 +62,8 @@ AVFILTER_DEFINE_CLASS(displace);
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
     AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR, AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA,
     AV_PIX_FMT_0RGB, AV_PIX_FMT_0BGR, AV_PIX_FMT_RGB0, AV_PIX_FMT_BGR0,
diff --git a/libavfilter/vf_drawbox.c b/libavfilter/vf_drawbox.c
index 27739dc89f..1d0dfb4cb9 100644
--- a/libavfilter/vf_drawbox.c
+++ b/libavfilter/vf_drawbox.c
@@ -256,9 +256,7 @@ static av_cold int init(AVFilterContext *ctx)
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV410P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUV440P,  AV_PIX_FMT_YUVJ440P,
+    AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV410P,  AV_PIX_FMT_YUV440P,
     AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
     AV_PIX_FMT_RGB24,  AV_PIX_FMT_BGR24,
     AV_PIX_FMT_RGBA,   AV_PIX_FMT_BGRA,
diff --git a/libavfilter/vf_entropy.c b/libavfilter/vf_entropy.c
index 694a3ee872..84ca584e43 100644
--- a/libavfilter/vf_entropy.c
+++ b/libavfilter/vf_entropy.c
@@ -54,8 +54,6 @@ AVFILTER_DEFINE_CLASS(entropy);
 static const enum AVPixelFormat pixfmts[] = {
     AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P,
-    AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV420P9,
     AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV420P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_estdif.c b/libavfilter/vf_estdif.c
index 471def9fa7..dd0c347fc0 100644
--- a/libavfilter/vf_estdif.c
+++ b/libavfilter/vf_estdif.c
@@ -109,9 +109,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
     AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
     AV_PIX_FMT_GRAY8,
diff --git a/libavfilter/vf_extractplanes.c b/libavfilter/vf_extractplanes.c
index 7b7149ab24..30ab67003b 100644
--- a/libavfilter/vf_extractplanes.c
+++ b/libavfilter/vf_extractplanes.c
@@ -72,9 +72,6 @@ AVFILTER_DEFINE_CLASS(extractplanes);
         AV_PIX_FMT_YUV440P,                        \
         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P,   \
         AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA422P,   \
-        AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,  \
-        AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,  \
-        AV_PIX_FMT_YUVJ411P,                       \
         AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P,   \
         AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8A,       \
         AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,        \
diff --git a/libavfilter/vf_fade.c b/libavfilter/vf_fade.c
index f903db0415..17367af3d6 100644
--- a/libavfilter/vf_fade.c
+++ b/libavfilter/vf_fade.c
@@ -106,9 +106,7 @@ static int query_formats(AVFilterContext *ctx)
     const FadeContext *s = ctx->priv;
     static const enum AVPixelFormat pix_fmts[] = {
         AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV420P,
-        AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV410P,
-        AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-        AV_PIX_FMT_YUV440P,  AV_PIX_FMT_YUVJ440P,
+        AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV440P,
         AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
         AV_PIX_FMT_RGB24,    AV_PIX_FMT_BGR24,
         AV_PIX_FMT_ARGB,     AV_PIX_FMT_ABGR,
diff --git a/libavfilter/vf_fftdnoiz.c b/libavfilter/vf_fftdnoiz.c
index 1489f3282b..f0a17d4e7f 100644
--- a/libavfilter/vf_fftdnoiz.c
+++ b/libavfilter/vf_fftdnoiz.c
@@ -119,9 +119,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_fftfilt.c b/libavfilter/vf_fftfilt.c
index aea83dc19c..0b13511025 100644
--- a/libavfilter/vf_fftfilt.c
+++ b/libavfilter/vf_fftfilt.c
@@ -569,9 +569,7 @@ static const enum AVPixelFormat pixel_fmts_fftfilt[] = {
     AV_PIX_FMT_GRAY8,
     AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
     AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16,
-    AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVJ422P,
+    AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV420P14,
     AV_PIX_FMT_YUV420P16,
diff --git a/libavfilter/vf_fieldmatch.c b/libavfilter/vf_fieldmatch.c
index 55671d8517..8b49e2093a 100644
--- a/libavfilter/vf_fieldmatch.c
+++ b/libavfilter/vf_fieldmatch.c
@@ -920,9 +920,6 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
         AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-        AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-        AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-        AV_PIX_FMT_YUVJ411P,
         AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
         AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
         AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_fillborders.c b/libavfilter/vf_fillborders.c
index 34e7b5f637..831c6b5dc8 100644
--- a/libavfilter/vf_fillborders.c
+++ b/libavfilter/vf_fillborders.c
@@ -56,10 +56,8 @@ typedef struct FillBordersContext {
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_find_rect.c b/libavfilter/vf_find_rect.c
index 9f4ee1e32f..d524c74978 100644
--- a/libavfilter/vf_find_rect.c
+++ b/libavfilter/vf_find_rect.c
@@ -291,6 +291,6 @@ const AVFilter ff_vf_find_rect = {
     .flags           = AVFILTER_FLAG_METADATA_ONLY,
     FILTER_INPUTS(foc_inputs),
     FILTER_OUTPUTS(ff_video_default_filterpad),
-    FILTER_PIXFMTS(AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P),
+    FILTER_PIXFMTS(AV_PIX_FMT_YUV420P),
     .priv_class      = &find_rect_class,
 };
diff --git a/libavfilter/vf_framepack.c b/libavfilter/vf_framepack.c
index 3b915ddddf..4541ac0397 100644
--- a/libavfilter/vf_framepack.c
+++ b/libavfilter/vf_framepack.c
@@ -58,9 +58,6 @@ static const enum AVPixelFormat formats_supported[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_framerate.c b/libavfilter/vf_framerate.c
index 6d448be74c..366809e358 100644
--- a/libavfilter/vf_framerate.c
+++ b/libavfilter/vf_framerate.c
@@ -218,11 +218,11 @@ static av_cold void uninit(AVFilterContext *ctx)
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P,
-    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUVJ411P,
-    AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUVJ440P,
-    AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
+    AV_PIX_FMT_YUV411P,
+    AV_PIX_FMT_YUV420P,
+    AV_PIX_FMT_YUV422P,
+    AV_PIX_FMT_YUV440P,
+    AV_PIX_FMT_YUV444P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV420P12,
     AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV422P12,
     AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV444P12,
diff --git a/libavfilter/vf_freezedetect.c b/libavfilter/vf_freezedetect.c
index 18d392d9ae..8deb5383b4 100644
--- a/libavfilter/vf_freezedetect.c
+++ b/libavfilter/vf_freezedetect.c
@@ -66,10 +66,9 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUYV422, AV_PIX_FMT_RGB24,
     AV_PIX_FMT_BGR24, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P,
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_GRAY8,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_UYVY422, AV_PIX_FMT_NV12, AV_PIX_FMT_NV21, AV_PIX_FMT_ARGB,
     AV_PIX_FMT_RGBA, AV_PIX_FMT_ABGR, AV_PIX_FMT_BGRA, AV_PIX_FMT_GRAY16,
-    AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVA420P,
+    AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUVA420P,
     AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
     AV_PIX_FMT_YA8, AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10,
     AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV444P10,
@@ -82,7 +81,7 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP16, AV_PIX_FMT_YUV420P12,
     AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV422P14,
     AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV444P14, AV_PIX_FMT_GBRP12,
-    AV_PIX_FMT_GBRP14, AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV440P10,
+    AV_PIX_FMT_GBRP14, AV_PIX_FMT_YUV440P10,
     AV_PIX_FMT_YUV440P12, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP10,
     AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY9,
     AV_PIX_FMT_GRAY14,
diff --git a/libavfilter/vf_fspp.c b/libavfilter/vf_fspp.c
index 8f44390117..6babebccdd 100644
--- a/libavfilter/vf_fspp.c
+++ b/libavfilter/vf_fspp.c
@@ -497,8 +497,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV420P,  AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV410P,  AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_GBRP, AV_PIX_FMT_GRAY8,
     AV_PIX_FMT_NONE
 };
diff --git a/libavfilter/vf_gblur.c b/libavfilter/vf_gblur.c
index 6ce2c84736..5e20b7a1a6 100644
--- a/libavfilter/vf_gblur.c
+++ b/libavfilter/vf_gblur.c
@@ -138,10 +138,8 @@ static void gaussianiir2d(AVFilterContext *ctx, int plane)
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_guided.c b/libavfilter/vf_guided.c
index 8c0e5e454e..ea070cea76 100644
--- a/libavfilter/vf_guided.c
+++ b/libavfilter/vf_guided.c
@@ -143,10 +143,8 @@ static int box_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_histogram.c b/libavfilter/vf_histogram.c
index 83477692cd..9926a65963 100644
--- a/libavfilter/vf_histogram.c
+++ b/libavfilter/vf_histogram.c
@@ -105,11 +105,11 @@ static const AVOption histogram_options[] = {
 AVFILTER_DEFINE_CLASS(histogram);
 
 static const enum AVPixelFormat levels_in_pix_fmts[] = {
-    AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUVJ411P,
+    AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
+    AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P,
+    AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV440P,  AV_PIX_FMT_YUV410P,
-    AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
+    AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
diff --git a/libavfilter/vf_hqdn3d.c b/libavfilter/vf_hqdn3d.c
index d95ae8f898..16c1f88137 100644
--- a/libavfilter/vf_hqdn3d.c
+++ b/libavfilter/vf_hqdn3d.c
@@ -232,7 +232,6 @@ static av_cold void uninit(AVFilterContext *ctx)
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P,
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_hysteresis.c b/libavfilter/vf_hysteresis.c
index d2fd3011b8..d1ef30e932 100644
--- a/libavfilter/vf_hysteresis.c
+++ b/libavfilter/vf_hysteresis.c
@@ -59,10 +59,8 @@ static const AVOption hysteresis_options[] = {
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_identity.c b/libavfilter/vf_identity.c
index d3a5ec14f6..68e86235cc 100644
--- a/libavfilter/vf_identity.c
+++ b/libavfilter/vf_identity.c
@@ -248,8 +248,6 @@ static const enum AVPixelFormat pix_fmts[] = {
 #define PF(suf)         PF_NOALPHA(suf), PF_ALPHA(suf)
     PF(P), PF(P9), PF(P10), PF_NOALPHA(P12), PF_NOALPHA(P14), PF(P16),
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
     AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
     AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
diff --git a/libavfilter/vf_idet.c b/libavfilter/vf_idet.c
index abd375230a..9bb3ab83a3 100644
--- a/libavfilter/vf_idet.c
+++ b/libavfilter/vf_idet.c
@@ -400,12 +400,8 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_GRAY8,
-    AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_GRAY16,
     AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUV420P9,
     AV_PIX_FMT_YUV422P9,
     AV_PIX_FMT_YUV444P9,
diff --git a/libavfilter/vf_lagfun.c b/libavfilter/vf_lagfun.c
index 20cdd9fa65..de2c0dd602 100644
--- a/libavfilter/vf_lagfun.c
+++ b/libavfilter/vf_lagfun.c
@@ -49,9 +49,6 @@ static const enum AVPixelFormat pixel_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_lenscorrection.c b/libavfilter/vf_lenscorrection.c
index 413eabefba..e9224b277b 100644
--- a/libavfilter/vf_lenscorrection.c
+++ b/libavfilter/vf_lenscorrection.c
@@ -182,9 +182,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_limitdiff.c b/libavfilter/vf_limitdiff.c
index 1e903d45a8..5b78a40faf 100644
--- a/libavfilter/vf_limitdiff.c
+++ b/libavfilter/vf_limitdiff.c
@@ -65,10 +65,8 @@ static const AVOption limitdiff_options[] = {
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_limiter.c b/libavfilter/vf_limiter.c
index f67f590d60..b41926eae6 100644
--- a/libavfilter/vf_limiter.c
+++ b/libavfilter/vf_limiter.c
@@ -67,10 +67,8 @@ static av_cold int init(AVFilterContext *ctx)
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_lut.c b/libavfilter/vf_lut.c
index 1a6ca06546..375a1d25d3 100644
--- a/libavfilter/vf_lut.c
+++ b/libavfilter/vf_lut.c
@@ -115,8 +115,6 @@ static av_cold void uninit(AVFilterContext *ctx)
     AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV420P,    \
     AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV410P,  AV_PIX_FMT_YUV440P,    \
     AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,   \
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,   \
-    AV_PIX_FMT_YUVJ440P,                                             \
     AV_PIX_FMT_YUV444P9LE, AV_PIX_FMT_YUV422P9LE, AV_PIX_FMT_YUV420P9LE, \
     AV_PIX_FMT_YUV444P10LE, AV_PIX_FMT_YUV422P10LE, AV_PIX_FMT_YUV420P10LE, AV_PIX_FMT_YUV440P10LE, \
     AV_PIX_FMT_YUV444P12LE, AV_PIX_FMT_YUV422P12LE, AV_PIX_FMT_YUV420P12LE, AV_PIX_FMT_YUV440P12LE, \
diff --git a/libavfilter/vf_lut2.c b/libavfilter/vf_lut2.c
index 49755544b0..a4818b08ba 100644
--- a/libavfilter/vf_lut2.c
+++ b/libavfilter/vf_lut2.c
@@ -110,10 +110,8 @@ static av_cold void uninit(AVFilterContext *ctx)
 
 #define BIT8_FMTS \
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P, \
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, \
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P, \
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P, \
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P, \
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P, \
     AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
 
 #define BIT9_FMTS \
diff --git a/libavfilter/vf_maskedclamp.c b/libavfilter/vf_maskedclamp.c
index e6fbb1a6d5..021c5d84bd 100644
--- a/libavfilter/vf_maskedclamp.c
+++ b/libavfilter/vf_maskedclamp.c
@@ -61,10 +61,8 @@ AVFILTER_DEFINE_CLASS(maskedclamp);
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_maskedmerge.c b/libavfilter/vf_maskedmerge.c
index 4ca0c571c8..2717e6b76a 100644
--- a/libavfilter/vf_maskedmerge.c
+++ b/libavfilter/vf_maskedmerge.c
@@ -38,10 +38,8 @@ AVFILTER_DEFINE_CLASS(maskedmerge);
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV440P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_maskedminmax.c b/libavfilter/vf_maskedminmax.c
index b1c309cc7d..80221bdd96 100644
--- a/libavfilter/vf_maskedminmax.c
+++ b/libavfilter/vf_maskedminmax.c
@@ -64,10 +64,8 @@ static av_cold int maskedmin_init(AVFilterContext *ctx)
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_maskedthreshold.c b/libavfilter/vf_maskedthreshold.c
index 36c4050b98..54f17f6e75 100644
--- a/libavfilter/vf_maskedthreshold.c
+++ b/libavfilter/vf_maskedthreshold.c
@@ -61,10 +61,8 @@ static const AVOption maskedthreshold_options[] = {
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_maskfun.c b/libavfilter/vf_maskfun.c
index 1ac152fc8b..d6dca71a67 100644
--- a/libavfilter/vf_maskfun.c
+++ b/libavfilter/vf_maskfun.c
@@ -63,10 +63,8 @@ AVFILTER_DEFINE_CLASS(maskfun);
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_median.c b/libavfilter/vf_median.c
index 57514f9289..975738513a 100644
--- a/libavfilter/vf_median.c
+++ b/libavfilter/vf_median.c
@@ -84,10 +84,8 @@ static void hmuladd(htype *dst, const htype *src, int f, int bins)
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_GBRP9,
     AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
diff --git a/libavfilter/vf_mestimate.c b/libavfilter/vf_mestimate.c
index 4ec34cd7fb..d533d4d7d3 100644
--- a/libavfilter/vf_mestimate.c
+++ b/libavfilter/vf_mestimate.c
@@ -68,9 +68,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
     AV_PIX_FMT_GRAY8,
     AV_PIX_FMT_NONE
diff --git a/libavfilter/vf_midequalizer.c b/libavfilter/vf_midequalizer.c
index fae2b7ef19..0c2749d271 100644
--- a/libavfilter/vf_midequalizer.c
+++ b/libavfilter/vf_midequalizer.c
@@ -58,10 +58,8 @@ AVFILTER_DEFINE_CLASS(midequalizer);
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
     AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
diff --git a/libavfilter/vf_minterpolate.c b/libavfilter/vf_minterpolate.c
index 9920210ece..17b4c238ac 100644
--- a/libavfilter/vf_minterpolate.c
+++ b/libavfilter/vf_minterpolate.c
@@ -237,9 +237,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
     AV_PIX_FMT_GRAY8,
     AV_PIX_FMT_NONE
diff --git a/libavfilter/vf_monochrome.c b/libavfilter/vf_monochrome.c
index 05c001707a..09b0a30005 100644
--- a/libavfilter/vf_monochrome.c
+++ b/libavfilter/vf_monochrome.c
@@ -225,9 +225,6 @@ static const enum AVPixelFormat pixel_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_morpho.c b/libavfilter/vf_morpho.c
index bd1d6b230f..09a126326a 100644
--- a/libavfilter/vf_morpho.c
+++ b/libavfilter/vf_morpho.c
@@ -147,10 +147,8 @@ FRAMESYNC_DEFINE_CLASS(morpho, MorphoContext, fs);
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_GBRP9,
     AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
diff --git a/libavfilter/vf_mpdecimate.c b/libavfilter/vf_mpdecimate.c
index baba1f183f..22ec07c9b8 100644
--- a/libavfilter/vf_mpdecimate.c
+++ b/libavfilter/vf_mpdecimate.c
@@ -176,8 +176,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV444P,      AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV420P,      AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV410P,      AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P,     AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ420P,     AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA420P,
 
     AV_PIX_FMT_GBRP,
diff --git a/libavfilter/vf_negate.c b/libavfilter/vf_negate.c
index 58be43a44b..b04c875663 100644
--- a/libavfilter/vf_negate.c
+++ b/libavfilter/vf_negate.c
@@ -80,8 +80,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV420P,
     AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV410P,  AV_PIX_FMT_YUV440P,
     AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV420P9,
     AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV440P10,
     AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_neighbor.c b/libavfilter/vf_neighbor.c
index 915347d6ba..86f7e35cad 100644
--- a/libavfilter/vf_neighbor.c
+++ b/libavfilter/vf_neighbor.c
@@ -52,10 +52,8 @@ typedef struct NContext {
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_nlmeans.c b/libavfilter/vf_nlmeans.c
index dc935538f0..42c5c2f2f1 100644
--- a/libavfilter/vf_nlmeans.c
+++ b/libavfilter/vf_nlmeans.c
@@ -77,9 +77,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP,
     AV_PIX_FMT_NONE
 };
diff --git a/libavfilter/vf_nnedi.c b/libavfilter/vf_nnedi.c
index 1bb8c21e10..3face927b9 100644
--- a/libavfilter/vf_nnedi.c
+++ b/libavfilter/vf_nnedi.c
@@ -185,9 +185,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
     AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
diff --git a/libavfilter/vf_ocr.c b/libavfilter/vf_ocr.c
index 3cece91edf..678da4ecaf 100644
--- a/libavfilter/vf_ocr.c
+++ b/libavfilter/vf_ocr.c
@@ -77,9 +77,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
     AV_PIX_FMT_NONE
 };
diff --git a/libavfilter/vf_overlay.c b/libavfilter/vf_overlay.c
index fa39abb23a..8848dc2c77 100644
--- a/libavfilter/vf_overlay.c
+++ b/libavfilter/vf_overlay.c
@@ -167,7 +167,7 @@ static int query_formats(AVFilterContext *ctx)
 
     /* overlay formats contains alpha, for avoiding conversion with alpha information loss */
     static const enum AVPixelFormat main_pix_fmts_yuv420[] = {
-        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVA420P,
+        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P,
         AV_PIX_FMT_NV12, AV_PIX_FMT_NV21,
         AV_PIX_FMT_NONE
     };
@@ -184,7 +184,7 @@ static int query_formats(AVFilterContext *ctx)
     };
 
     static const enum AVPixelFormat main_pix_fmts_yuv422[] = {
-        AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_NONE
+        AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_NONE
     };
     static const enum AVPixelFormat overlay_pix_fmts_yuv422[] = {
         AV_PIX_FMT_YUVA422P, AV_PIX_FMT_NONE
@@ -198,7 +198,7 @@ static int query_formats(AVFilterContext *ctx)
     };
 
     static const enum AVPixelFormat main_pix_fmts_yuv444[] = {
-        AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVA444P, AV_PIX_FMT_NONE
+        AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P, AV_PIX_FMT_NONE
     };
     static const enum AVPixelFormat overlay_pix_fmts_yuv444[] = {
         AV_PIX_FMT_YUVA444P, AV_PIX_FMT_NONE
diff --git a/libavfilter/vf_perspective.c b/libavfilter/vf_perspective.c
index f06c44b33a..fc9879baa1 100644
--- a/libavfilter/vf_perspective.c
+++ b/libavfilter/vf_perspective.c
@@ -95,7 +95,6 @@ AVFILTER_DEFINE_CLASS(perspective);
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ422P,AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE
 };
diff --git a/libavfilter/vf_phase.c b/libavfilter/vf_phase.c
index 02dd08e002..090ad13111 100644
--- a/libavfilter/vf_phase.c
+++ b/libavfilter/vf_phase.c
@@ -102,9 +102,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_pixelize.c b/libavfilter/vf_pixelize.c
index a436515986..06204f47cd 100644
--- a/libavfilter/vf_pixelize.c
+++ b/libavfilter/vf_pixelize.c
@@ -66,9 +66,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_pp.c b/libavfilter/vf_pp.c
index aa37325a24..774e006172 100644
--- a/libavfilter/vf_pp.c
+++ b/libavfilter/vf_pp.c
@@ -77,12 +77,12 @@ static int pp_process_command(AVFilterContext *ctx, const char *cmd, const char
 }
 
 static const enum AVPixelFormat pix_fmts[] = {
-    AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVJ422P,
+    AV_PIX_FMT_YUV420P,
+    AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_GBRP,
-    AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUVJ440P,
+    AV_PIX_FMT_YUV444P,
+    AV_PIX_FMT_YUV440P,
     AV_PIX_FMT_GRAY8,
     AV_PIX_FMT_NONE
 };
@@ -94,15 +94,11 @@ static int pp_config_props(AVFilterLink *inlink)
 
     switch (inlink->format) {
     case AV_PIX_FMT_GRAY8:
-    case AV_PIX_FMT_YUVJ420P:
     case AV_PIX_FMT_YUV420P: flags |= PP_FORMAT_420; break;
-    case AV_PIX_FMT_YUVJ422P:
     case AV_PIX_FMT_YUV422P: flags |= PP_FORMAT_422; break;
     case AV_PIX_FMT_YUV411P: flags |= PP_FORMAT_411; break;
     case AV_PIX_FMT_GBRP:
-    case AV_PIX_FMT_YUVJ444P:
     case AV_PIX_FMT_YUV444P: flags |= PP_FORMAT_444; break;
-    case AV_PIX_FMT_YUVJ440P:
     case AV_PIX_FMT_YUV440P: flags |= PP_FORMAT_440; break;
     default: av_assert0(0);
     }
diff --git a/libavfilter/vf_pp7.c b/libavfilter/vf_pp7.c
index 24a094f00c..0db4b94b5d 100644
--- a/libavfilter/vf_pp7.c
+++ b/libavfilter/vf_pp7.c
@@ -270,8 +270,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV420P,  AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV410P,  AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_GBRP,
     AV_PIX_FMT_GRAY8,    AV_PIX_FMT_NONE
 };
diff --git a/libavfilter/vf_premultiply.c b/libavfilter/vf_premultiply.c
index e077d46a9a..0ebb94058c 100644
--- a/libavfilter/vf_premultiply.c
+++ b/libavfilter/vf_premultiply.c
@@ -69,7 +69,7 @@ static int query_formats(AVFilterContext *ctx)
     PreMultiplyContext *s = ctx->priv;
 
     static const enum AVPixelFormat no_alpha_pix_fmts[] = {
-        AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
+        AV_PIX_FMT_YUV444P,
         AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV444P10,
         AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV444P14,
         AV_PIX_FMT_YUV444P16,
@@ -534,10 +534,6 @@ static int filter_frame(AVFilterContext *ctx,
                 s->premultiply[0] = full ? unpremultiply8 : unpremultiply8offset;
                 s->premultiply[1] = s->premultiply[2] = unpremultiply8yuv;
                 break;
-            case AV_PIX_FMT_YUVJ444P:
-                s->premultiply[0] = unpremultiply8;
-                s->premultiply[1] = s->premultiply[2] = unpremultiply8yuv;
-                break;
             case AV_PIX_FMT_GBRP:
             case AV_PIX_FMT_GBRAP:
                 s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? unpremultiply8offset : unpremultiply8;
@@ -586,10 +582,6 @@ static int filter_frame(AVFilterContext *ctx,
                 s->premultiply[0] = full ? premultiply8 : premultiply8offset;
                 s->premultiply[1] = s->premultiply[2] = premultiply8yuv;
                 break;
-            case AV_PIX_FMT_YUVJ444P:
-                s->premultiply[0] = premultiply8;
-                s->premultiply[1] = s->premultiply[2] = premultiply8yuv;
-                break;
             case AV_PIX_FMT_GBRP:
             case AV_PIX_FMT_GBRAP:
                 s->premultiply[0] = s->premultiply[1] = s->premultiply[2] = limited ? premultiply8offset : premultiply8;
diff --git a/libavfilter/vf_psnr.c b/libavfilter/vf_psnr.c
index 058a8932f4..dd05e61059 100644
--- a/libavfilter/vf_psnr.c
+++ b/libavfilter/vf_psnr.c
@@ -309,8 +309,6 @@ static const enum AVPixelFormat pix_fmts[] = {
 #define PF(suf)         PF_NOALPHA(suf), PF_ALPHA(suf)
     PF(P), PF(P9), PF(P10), PF_NOALPHA(P12), PF_NOALPHA(P14), PF(P16),
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
     AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
     AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
diff --git a/libavfilter/vf_pullup.c b/libavfilter/vf_pullup.c
index 14beb972c5..ce4052abb0 100644
--- a/libavfilter/vf_pullup.c
+++ b/libavfilter/vf_pullup.c
@@ -53,12 +53,10 @@ static const AVOption pullup_options[] = {
 AVFILTER_DEFINE_CLASS(pullup);
 
 static const enum AVPixelFormat pix_fmts[] = {
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
     AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV440P,
     AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV420P,
     AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV410P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_GRAY8,
+    AV_PIX_FMT_GRAY8,
     AV_PIX_FMT_NONE
 };
 
diff --git a/libavfilter/vf_readeia608.c b/libavfilter/vf_readeia608.c
index 50bf915765..49ac554176 100644
--- a/libavfilter/vf_readeia608.c
+++ b/libavfilter/vf_readeia608.c
@@ -105,9 +105,6 @@ static const enum AVPixelFormat pixel_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_readvitc.c b/libavfilter/vf_readvitc.c
index cb63a4d127..9055507ca6 100644
--- a/libavfilter/vf_readvitc.c
+++ b/libavfilter/vf_readvitc.c
@@ -197,11 +197,6 @@ static const enum AVPixelFormat pixel_fmts[] = {
     AV_PIX_FMT_YUVA420P,
     AV_PIX_FMT_YUVA422P,
     AV_PIX_FMT_YUVA444P,
-    AV_PIX_FMT_YUVJ411P,
-    AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P,
-    AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_NONE
 };
 
diff --git a/libavfilter/vf_remap.c b/libavfilter/vf_remap.c
index f536580a90..4f53c1e14a 100644
--- a/libavfilter/vf_remap.c
+++ b/libavfilter/vf_remap.c
@@ -88,7 +88,6 @@ static int query_formats(AVFilterContext *ctx)
     static const enum AVPixelFormat pix_fmts[] = {
         AV_PIX_FMT_YUVA444P,
         AV_PIX_FMT_YUV444P,
-        AV_PIX_FMT_YUVJ444P,
         AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
         AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR, AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA,
         AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
diff --git a/libavfilter/vf_removegrain.c b/libavfilter/vf_removegrain.c
index 6e6e99198c..25f5a18882 100644
--- a/libavfilter/vf_removegrain.c
+++ b/libavfilter/vf_removegrain.c
@@ -48,8 +48,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P,
     AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
     AV_PIX_FMT_NONE
 };
diff --git a/libavfilter/vf_rotate.c b/libavfilter/vf_rotate.c
index 96c250a459..38f98d75ab 100644
--- a/libavfilter/vf_rotate.c
+++ b/libavfilter/vf_rotate.c
@@ -141,8 +141,8 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_RGB24,  AV_PIX_FMT_BGR24,
     AV_PIX_FMT_GRAY8,
     AV_PIX_FMT_YUV410P,
-    AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUV420P,  AV_PIX_FMT_YUVJ420P,
+    AV_PIX_FMT_YUV444P,
+    AV_PIX_FMT_YUV420P,
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA420P,
     AV_PIX_FMT_YUV420P10LE, AV_PIX_FMT_YUVA420P10LE,
     AV_PIX_FMT_YUV444P10LE, AV_PIX_FMT_YUVA444P10LE,
diff --git a/libavfilter/vf_scdet.c b/libavfilter/vf_scdet.c
index 15399cfebf..ac7e1314d9 100644
--- a/libavfilter/vf_scdet.c
+++ b/libavfilter/vf_scdet.c
@@ -63,10 +63,10 @@ AVFILTER_DEFINE_CLASS(scdet);
 static const enum AVPixelFormat pix_fmts[] = {
         AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24, AV_PIX_FMT_RGBA,
         AV_PIX_FMT_ABGR, AV_PIX_FMT_BGRA, AV_PIX_FMT_GRAY8,
-        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P,
-        AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVJ422P,
-        AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUVJ440P,
-        AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
+        AV_PIX_FMT_YUV420P,
+        AV_PIX_FMT_YUV422P,
+        AV_PIX_FMT_YUV440P,
+        AV_PIX_FMT_YUV444P,
         AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV420P12,
         AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV422P12,
         AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV444P12,
diff --git a/libavfilter/vf_scroll.c b/libavfilter/vf_scroll.c
index eebf12e902..f1e1bd61f2 100644
--- a/libavfilter/vf_scroll.c
+++ b/libavfilter/vf_scroll.c
@@ -44,10 +44,8 @@ typedef struct ScrollContext {
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_shear.c b/libavfilter/vf_shear.c
index 760caa5011..58b84e0975 100644
--- a/libavfilter/vf_shear.c
+++ b/libavfilter/vf_shear.c
@@ -92,9 +92,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_signalstats.c b/libavfilter/vf_signalstats.c
index b4d1029296..3112baa69f 100644
--- a/libavfilter/vf_signalstats.c
+++ b/libavfilter/vf_signalstats.c
@@ -121,8 +121,6 @@ static av_cold void uninit(AVFilterContext *ctx)
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ411P,
-    AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV420P9,
     AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV420P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_signature.c b/libavfilter/vf_signature.c
index 4896e8f2c1..1a3d1b2bc1 100644
--- a/libavfilter/vf_signature.c
+++ b/libavfilter/vf_signature.c
@@ -73,9 +73,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_NV12, AV_PIX_FMT_NV21,
     AV_PIX_FMT_NONE
 };
diff --git a/libavfilter/vf_siti.c b/libavfilter/vf_siti.c
index 1b6ff32d6e..ad8d90d9ec 100644
--- a/libavfilter/vf_siti.c
+++ b/libavfilter/vf_siti.c
@@ -66,7 +66,6 @@ typedef struct SiTiContext {
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10,
     AV_PIX_FMT_NONE
 };
@@ -140,15 +139,6 @@ static int config_input(AVFilterLink *inlink)
     return 0;
 }
 
-// Determine whether the video is in full or limited range. If not defined, assume limited.
-static int is_full_range(AVFrame* frame)
-{
-    // If color range not specified, fallback to pixel format
-    if (frame->color_range == AVCOL_RANGE_UNSPECIFIED || frame->color_range == AVCOL_RANGE_NB)
-        return frame->format == AV_PIX_FMT_YUVJ420P || frame->format == AV_PIX_FMT_YUVJ422P;
-    return frame->color_range == AVCOL_RANGE_JPEG;
-}
-
 // Check frame's color range and convert to full range if needed
 static uint16_t convert_full_range(int factor, uint16_t y)
 {
@@ -284,7 +274,7 @@ static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
     float si;
     float ti;
 
-    s->full_range = is_full_range(frame);
+    s->full_range = frame->color_range == AVCOL_RANGE_JPEG;
     s->nb_frames++;
 
     // Calculate si and ti
diff --git a/libavfilter/vf_spp.c b/libavfilter/vf_spp.c
index bb74b20e0e..05285e6be5 100644
--- a/libavfilter/vf_spp.c
+++ b/libavfilter/vf_spp.c
@@ -316,8 +316,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV420P,  AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV410P,  AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUV444P10,  AV_PIX_FMT_YUV422P10,
     AV_PIX_FMT_YUV420P10,
     AV_PIX_FMT_YUV444P9,  AV_PIX_FMT_YUV422P9,
diff --git a/libavfilter/vf_ssim.c b/libavfilter/vf_ssim.c
index 53eb72fe6a..5168ac387b 100644
--- a/libavfilter/vf_ssim.c
+++ b/libavfilter/vf_ssim.c
@@ -431,8 +431,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_GBRP,
 #define PF(suf) AV_PIX_FMT_YUV420##suf,  AV_PIX_FMT_YUV422##suf,  AV_PIX_FMT_YUV444##suf, AV_PIX_FMT_GBR##suf
     PF(P9), PF(P10), PF(P12), PF(P14), PF(P16),
diff --git a/libavfilter/vf_ssim360.c b/libavfilter/vf_ssim360.c
index 3dec430bff..1dc08e12b6 100644
--- a/libavfilter/vf_ssim360.c
+++ b/libavfilter/vf_ssim360.c
@@ -1716,8 +1716,6 @@ static const enum AVPixelFormat ssim360_pixfmts[] = {
     AV_PIX_FMT_GRAY8,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_GBRP,
     PF(P9), PF(P10), PF(P12), PF(P14), PF(P16),
     AV_PIX_FMT_NONE
diff --git a/libavfilter/vf_stereo3d.c b/libavfilter/vf_stereo3d.c
index 71041d2fee..3ffecea448 100644
--- a/libavfilter/vf_stereo3d.c
+++ b/libavfilter/vf_stereo3d.c
@@ -247,11 +247,6 @@ static const enum AVPixelFormat other_pix_fmts[] = {
     AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA422P,
     AV_PIX_FMT_YUV440P,
     AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P,
-    AV_PIX_FMT_YUVJ411P,
-    AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P,
-    AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_YUV420P9LE,  AV_PIX_FMT_YUVA420P9LE,
     AV_PIX_FMT_YUV420P9BE,  AV_PIX_FMT_YUVA420P9BE,
     AV_PIX_FMT_YUV422P9LE,  AV_PIX_FMT_YUVA422P9LE,
diff --git a/libavfilter/vf_threshold.c b/libavfilter/vf_threshold.c
index dc73c277d3..36e392fff5 100644
--- a/libavfilter/vf_threshold.c
+++ b/libavfilter/vf_threshold.c
@@ -46,10 +46,8 @@ AVFILTER_DEFINE_CLASS(threshold);
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV440P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV440P12, AV_PIX_FMT_YUV444P12,
diff --git a/libavfilter/vf_thumbnail.c b/libavfilter/vf_thumbnail.c
index 4d6b0aef04..6f2ba813a1 100644
--- a/libavfilter/vf_thumbnail.c
+++ b/libavfilter/vf_thumbnail.c
@@ -298,9 +298,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
     AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
     AV_PIX_FMT_NONE
diff --git a/libavfilter/vf_tinterlace.c b/libavfilter/vf_tinterlace.c
index e221a6f941..96a4b6c567 100644
--- a/libavfilter/vf_tinterlace.c
+++ b/libavfilter/vf_tinterlace.c
@@ -75,13 +75,6 @@ static const AVOption interlace_options[] = {
 
 AVFILTER_DEFINE_CLASS(interlace);
 
-#define FULL_SCALE_YUVJ_FORMATS \
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P
-
-static const enum AVPixelFormat full_scale_yuvj_pix_fmts[] = {
-    FULL_SCALE_YUVJ_FORMATS, AV_PIX_FMT_NONE
-};
-
 static const AVRational standard_tbs[] = {
     {1, 25},
     {1, 30},
@@ -98,7 +91,7 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV440P12LE, AV_PIX_FMT_YUV444P12LE,
     AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
     AV_PIX_FMT_YUVA420P10LE, AV_PIX_FMT_YUVA422P10LE, AV_PIX_FMT_YUVA444P10LE,
-    AV_PIX_FMT_GRAY8, FULL_SCALE_YUVJ_FORMATS,
+    AV_PIX_FMT_GRAY8,
     AV_PIX_FMT_NONE
 };
 
@@ -228,14 +221,12 @@ static int config_out_props(AVFilterLink *outlink)
         ff_draw_init(&tinterlace->draw, outlink->format, 0);
         ff_draw_color(&tinterlace->draw, &tinterlace->color, black);
         /* limited range */
-        if (!ff_fmt_is_in(outlink->format, full_scale_yuvj_pix_fmts)) {
-            ret = av_image_alloc(tinterlace->black_data[0], tinterlace->black_linesize,
-                                 outlink->w, outlink->h, outlink->format, 16);
-            if (ret < 0)
-                return ret;
-            ff_fill_rectangle(&tinterlace->draw, &tinterlace->color, tinterlace->black_data[0],
-                              tinterlace->black_linesize, 0, 0, outlink->w, outlink->h);
-        }
+        ret = av_image_alloc(tinterlace->black_data[0], tinterlace->black_linesize,
+                             outlink->w, outlink->h, outlink->format, 16);
+        if (ret < 0)
+            return ret;
+        ff_fill_rectangle(&tinterlace->draw, &tinterlace->color, tinterlace->black_data[0],
+                          tinterlace->black_linesize, 0, 0, outlink->w, outlink->h);
         /* full range */
         tinterlace->color.comp[0].u8[0] = 0;
         ret = av_image_alloc(tinterlace->black_data[1], tinterlace->black_linesize,
@@ -441,7 +432,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
         out->sample_aspect_ratio = av_mul_q(cur->sample_aspect_ratio, av_make_q(2, 1));
 
         field = (1 + outlink->frame_count_in) & 1 ? FIELD_UPPER : FIELD_LOWER;
-        full = out->color_range == AVCOL_RANGE_JPEG || ff_fmt_is_in(out->format, full_scale_yuvj_pix_fmts);
+        full = out->color_range == AVCOL_RANGE_JPEG;
         /* copy upper and lower fields */
         copy_picture_field(tinterlace, out->data, out->linesize,
                            (const uint8_t **)cur->data, cur->linesize,
diff --git a/libavfilter/vf_tmidequalizer.c b/libavfilter/vf_tmidequalizer.c
index 650aa36636..13ab5b5aac 100644
--- a/libavfilter/vf_tmidequalizer.c
+++ b/libavfilter/vf_tmidequalizer.c
@@ -68,10 +68,8 @@ AVFILTER_DEFINE_CLASS(tmidequalizer);
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
     AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
diff --git a/libavfilter/vf_unsharp.c b/libavfilter/vf_unsharp.c
index 2705ac5270..8c75dce3b2 100644
--- a/libavfilter/vf_unsharp.c
+++ b/libavfilter/vf_unsharp.c
@@ -218,12 +218,12 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA422P12, AV_PIX_FMT_YUVA422P16,
     AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA420P16,
     AV_PIX_FMT_YUV420P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV410P,
-    AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV440P,  AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
+    AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV440P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV440P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
     AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_NONE
+    AV_PIX_FMT_NONE
 };
 
 static int init_filter_param(AVFilterContext *ctx, UnsharpFilterParam *fp, const char *effect_type, int width)
diff --git a/libavfilter/vf_uspp.c b/libavfilter/vf_uspp.c
index 10c8aaeb6c..444bad5add 100644
--- a/libavfilter/vf_uspp.c
+++ b/libavfilter/vf_uspp.c
@@ -339,8 +339,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV444P,
     AV_PIX_FMT_YUV420P,
     AV_PIX_FMT_YUV410P,
-    AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ420P,
     AV_PIX_FMT_GRAY8,
     AV_PIX_FMT_NONE
 };
diff --git a/libavfilter/vf_v360.c b/libavfilter/vf_v360.c
index 2ac9b688dc..ede5bb04a0 100644
--- a/libavfilter/vf_v360.c
+++ b/libavfilter/vf_v360.c
@@ -190,11 +190,6 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_YUVA420P,   AV_PIX_FMT_YUVA420P9,
         AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA420P16,
 
-        // YUVJ
-        AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
-        AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-        AV_PIX_FMT_YUVJ411P,
-
         // YUV444
         AV_PIX_FMT_YUV444P,   AV_PIX_FMT_YUV444P9,
         AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV444P12,
diff --git a/libavfilter/vf_vaguedenoiser.c b/libavfilter/vf_vaguedenoiser.c
index bfb6e9e262..3cf4afa945 100644
--- a/libavfilter/vf_vaguedenoiser.c
+++ b/libavfilter/vf_vaguedenoiser.c
@@ -109,9 +109,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_varblur.c b/libavfilter/vf_varblur.c
index 6ebb9c0663..8912a9581a 100644
--- a/libavfilter/vf_varblur.c
+++ b/libavfilter/vf_varblur.c
@@ -73,10 +73,8 @@ FRAMESYNC_DEFINE_CLASS(varblur, VarBlurContext, fs);
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_vectorscope.c b/libavfilter/vf_vectorscope.c
index 6a45b11463..6e04226ac5 100644
--- a/libavfilter/vf_vectorscope.c
+++ b/libavfilter/vf_vectorscope.c
@@ -181,7 +181,7 @@ static const enum AVPixelFormat out_rgb12_pix_fmts[] = {
 };
 
 static const enum AVPixelFormat in1_pix_fmts[] = {
-    AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
+    AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P,
     AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA444P10,
     AV_PIX_FMT_YUVA444P12, AV_PIX_FMT_YUV444P12,
@@ -192,10 +192,10 @@ static const enum AVPixelFormat in1_pix_fmts[] = {
 };
 
 static const enum AVPixelFormat in2_pix_fmts[] = {
-    AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUVJ411P,
+    AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
+    AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P,
+    AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P,
+    AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV440P,  AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRP,
     AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10,
diff --git a/libavfilter/vf_vif.c b/libavfilter/vf_vif.c
index a927abaf6f..3af32d5b9f 100644
--- a/libavfilter/vf_vif.c
+++ b/libavfilter/vf_vif.c
@@ -470,8 +470,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
 #define PF(suf) AV_PIX_FMT_YUV420##suf,  AV_PIX_FMT_YUV422##suf,  AV_PIX_FMT_YUV444##suf
     PF(P9), PF(P10), PF(P12), PF(P14), PF(P16),
     AV_PIX_FMT_NONE
diff --git a/libavfilter/vf_w3fdif.c b/libavfilter/vf_w3fdif.c
index f2264efe2b..44a7d8047a 100644
--- a/libavfilter/vf_w3fdif.c
+++ b/libavfilter/vf_w3fdif.c
@@ -76,9 +76,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
     AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
     AV_PIX_FMT_GRAY8,
diff --git a/libavfilter/vf_waveform.c b/libavfilter/vf_waveform.c
index a6a8ec78e7..7a765e7e14 100644
--- a/libavfilter/vf_waveform.c
+++ b/libavfilter/vf_waveform.c
@@ -211,8 +211,6 @@ static const enum AVPixelFormat in_lowpass_pix_fmts[] = {
     AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV420P,
     AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV440P,
     AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV410P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
     AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12,
     AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV420P9,
@@ -230,8 +228,6 @@ static const enum AVPixelFormat in_color_pix_fmts[] = {
     AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV420P,
     AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV440P,
     AV_PIX_FMT_YUV411P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
     AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV420P9,
     AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
@@ -246,8 +242,6 @@ static const enum AVPixelFormat in_flat_pix_fmts[] = {
     AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV420P,
     AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV440P,
     AV_PIX_FMT_YUV411P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA420P,
     AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV420P9,
     AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,
@@ -279,7 +273,7 @@ static const enum AVPixelFormat out_rgb12_lowpass_pix_fmts[] = {
 };
 
 static const enum AVPixelFormat out_yuv8_lowpass_pix_fmts[] = {
-    AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVA444P,
+    AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P,
     AV_PIX_FMT_NONE
 };
 
diff --git a/libavfilter/vf_xfade.c b/libavfilter/vf_xfade.c
index 890995a608..bc320aeef6 100644
--- a/libavfilter/vf_xfade.c
+++ b/libavfilter/vf_xfade.c
@@ -141,7 +141,6 @@ typedef struct ThreadData {
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P,
-    AV_PIX_FMT_YUVJ444P,
     AV_PIX_FMT_YUV444P,
     AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_GRAY8,
     AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_GBRP9,
diff --git a/libavfilter/vf_xmedian.c b/libavfilter/vf_xmedian.c
index 0a02ca065e..bb6b412edd 100644
--- a/libavfilter/vf_xmedian.c
+++ b/libavfilter/vf_xmedian.c
@@ -69,9 +69,6 @@ static const enum AVPixelFormat pixel_fmts[] = {
     AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
     AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
     AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-    AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-    AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV440P10,
diff --git a/libavfilter/vf_yadif.c b/libavfilter/vf_yadif.c
index a5a856bf5f..3c6bf7f43c 100644
--- a/libavfilter/vf_yadif.c
+++ b/libavfilter/vf_yadif.c
@@ -265,8 +265,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV420P,   AV_PIX_FMT_YUV422P,   AV_PIX_FMT_YUV444P,
     AV_PIX_FMT_YUV410P,   AV_PIX_FMT_YUV411P,   AV_PIX_FMT_YUV440P,
     AV_PIX_FMT_GRAY8,     AV_PIX_FMT_GRAY16,
-    AV_PIX_FMT_YUVJ420P,  AV_PIX_FMT_YUVJ422P,  AV_PIX_FMT_YUVJ444P,
-    AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUV420P9,  AV_PIX_FMT_YUV422P9,  AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
diff --git a/libavfilter/vf_yaepblur.c b/libavfilter/vf_yaepblur.c
index b39738b577..fd67fa3cbf 100644
--- a/libavfilter/vf_yaepblur.c
+++ b/libavfilter/vf_yaepblur.c
@@ -62,10 +62,8 @@ static av_cold void uninit(AVFilterContext *ctx)
 
 static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
     AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
+    AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
     AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
     AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
diff --git a/libavfilter/vf_zoompan.c b/libavfilter/vf_zoompan.c
index e729bda56d..873b73788b 100644
--- a/libavfilter/vf_zoompan.c
+++ b/libavfilter/vf_zoompan.c
@@ -330,9 +330,6 @@ static const enum AVPixelFormat pix_fmts[] = {
     AV_PIX_FMT_YUV410P,  AV_PIX_FMT_YUV440P,
     AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P,
     AV_PIX_FMT_YUVA420P,
-    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
-    AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
-    AV_PIX_FMT_YUVJ411P,
     AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
     AV_PIX_FMT_GRAY8,
     AV_PIX_FMT_NONE
diff --git a/libavfilter/vf_zscale.c b/libavfilter/vf_zscale.c
index 788870ffaf..eb2d896f4e 100644
--- a/libavfilter/vf_zscale.c
+++ b/libavfilter/vf_zscale.c
@@ -199,9 +199,6 @@ static int query_formats(AVFilterContext *ctx)
         AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
         AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
         AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
-        AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P,
-        AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_YUVJ444P,
-        AV_PIX_FMT_YUVJ411P,
         AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
         AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
         AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
diff --git a/libavfilter/vsrc_testsrc.c b/libavfilter/vsrc_testsrc.c
index 9081b55f1c..dddebd3d43 100644
--- a/libavfilter/vsrc_testsrc.c
+++ b/libavfilter/vsrc_testsrc.c
@@ -1274,7 +1274,7 @@ static av_cold int yuvtest_init(AVFilterContext *ctx)
 }
 
 static const enum AVPixelFormat yuvtest_pix_fmts[] = {
-    AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P,
+    AV_PIX_FMT_YUV444P,
     AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV444P10,
     AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV444P14,
     AV_PIX_FMT_YUV444P16,
diff --git a/libavformat/yuv4mpegenc.c b/libavformat/yuv4mpegenc.c
index 1d641eb9e4..34acb0820a 100644
--- a/libavformat/yuv4mpegenc.c
+++ b/libavformat/yuv4mpegenc.c
@@ -90,18 +90,6 @@ static int yuv4_write_header(AVFormatContext *s)
     case AV_PIX_FMT_YUV411P:
         colorspace = " C411 XYSCSS=411";
         break;
-    case AV_PIX_FMT_YUVJ420P:
-        colorspace = " C420jpeg XYSCSS=420JPEG";
-        colorrange = " XCOLORRANGE=FULL";
-        break;
-    case AV_PIX_FMT_YUVJ422P:
-        colorspace = " C422 XYSCSS=422";
-        colorrange = " XCOLORRANGE=FULL";
-        break;
-    case AV_PIX_FMT_YUVJ444P:
-        colorspace = " C444 XYSCSS=444";
-        colorrange = " XCOLORRANGE=FULL";
-        break;
     case AV_PIX_FMT_YUV420P:
         switch (st->codecpar->chroma_location) {
         case AVCHROMA_LOC_TOPLEFT: colorspace = " C420paldv XYSCSS=420PALDV"; break;
@@ -239,10 +227,6 @@ static int yuv4_init(AVFormatContext *s)
     case AV_PIX_FMT_YUV420P:
     case AV_PIX_FMT_YUV422P:
     case AV_PIX_FMT_YUV444P:
-    // TODO: remove YUVJ pixel formats when they are completely removed from the codebase.
-    case AV_PIX_FMT_YUVJ420P:
-    case AV_PIX_FMT_YUVJ422P:
-    case AV_PIX_FMT_YUVJ444P:
         break;
     case AV_PIX_FMT_GRAY9:
     case AV_PIX_FMT_GRAY10:
diff --git a/libavutil/pixdesc.c b/libavutil/pixdesc.c
index 6ded9467b0..d640624aaf 100644
--- a/libavutil/pixdesc.c
+++ b/libavutil/pixdesc.c
@@ -372,18 +372,6 @@ static const AVPixFmtDescriptor av_pix_fmt_descriptors[AV_PIX_FMT_NB] = {
         },
         .flags = AV_PIX_FMT_FLAG_PLANAR,
     },
-    [AV_PIX_FMT_YUVJ411P] = {
-        .name = "yuvj411p",
-        .nb_components = 3,
-        .log2_chroma_w = 2,
-        .log2_chroma_h = 0,
-        .comp = {
-            { 0, 1, 0, 0, 8 },        /* Y */
-            { 1, 1, 0, 0, 8 },        /* U */
-            { 2, 1, 0, 0, 8 },        /* V */
-        },
-        .flags = AV_PIX_FMT_FLAG_PLANAR,
-    },
     [AV_PIX_FMT_GRAY8] = {
         .name = "gray",
         .nb_components = 1,
@@ -424,42 +412,6 @@ static const AVPixFmtDescriptor av_pix_fmt_descriptors[AV_PIX_FMT_NB] = {
         },
         .flags = AV_PIX_FMT_FLAG_PAL | AV_PIX_FMT_FLAG_ALPHA,
     },
-    [AV_PIX_FMT_YUVJ420P] = {
-        .name = "yuvj420p",
-        .nb_components = 3,
-        .log2_chroma_w = 1,
-        .log2_chroma_h = 1,
-        .comp = {
-            { 0, 1, 0, 0, 8 },        /* Y */
-            { 1, 1, 0, 0, 8 },        /* U */
-            { 2, 1, 0, 0, 8 },        /* V */
-        },
-        .flags = AV_PIX_FMT_FLAG_PLANAR,
-    },
-    [AV_PIX_FMT_YUVJ422P] = {
-        .name = "yuvj422p",
-        .nb_components = 3,
-        .log2_chroma_w = 1,
-        .log2_chroma_h = 0,
-        .comp = {
-            { 0, 1, 0, 0, 8 },        /* Y */
-            { 1, 1, 0, 0, 8 },        /* U */
-            { 2, 1, 0, 0, 8 },        /* V */
-        },
-        .flags = AV_PIX_FMT_FLAG_PLANAR,
-    },
-    [AV_PIX_FMT_YUVJ444P] = {
-        .name = "yuvj444p",
-        .nb_components = 3,
-        .log2_chroma_w = 0,
-        .log2_chroma_h = 0,
-        .comp = {
-            { 0, 1, 0, 0, 8 },        /* Y */
-            { 1, 1, 0, 0, 8 },        /* U */
-            { 2, 1, 0, 0, 8 },        /* V */
-        },
-        .flags = AV_PIX_FMT_FLAG_PLANAR,
-    },
 #if FF_API_XVMC
     [AV_PIX_FMT_XVMC] = {
         .name = "xvmc",
@@ -801,18 +753,6 @@ static const AVPixFmtDescriptor av_pix_fmt_descriptors[AV_PIX_FMT_NB] = {
         },
         .flags = AV_PIX_FMT_FLAG_PLANAR,
     },
-    [AV_PIX_FMT_YUVJ440P] = {
-        .name = "yuvj440p",
-        .nb_components = 3,
-        .log2_chroma_w = 0,
-        .log2_chroma_h = 1,
-        .comp = {
-            { 0, 1, 0, 0, 8 },        /* Y */
-            { 1, 1, 0, 0, 8 },        /* U */
-            { 2, 1, 0, 0, 8 },        /* V */
-        },
-        .flags = AV_PIX_FMT_FLAG_PLANAR,
-    },
     [AV_PIX_FMT_YUV440P10LE] = {
         .name = "yuv440p10le",
         .nb_components = 3,
diff --git a/libavutil/pixfmt.h b/libavutil/pixfmt.h
index a26c72d56b..ee941b2fbb 100644
--- a/libavutil/pixfmt.h
+++ b/libavutil/pixfmt.h
@@ -75,9 +75,6 @@ enum AVPixelFormat {
     AV_PIX_FMT_MONOWHITE, ///<        Y        ,  1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb
     AV_PIX_FMT_MONOBLACK, ///<        Y        ,  1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb
     AV_PIX_FMT_PAL8,      ///< 8 bits with AV_PIX_FMT_RGB32 palette
-    AV_PIX_FMT_YUVJ420P,  ///< planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting color_range
-    AV_PIX_FMT_YUVJ422P,  ///< planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting color_range
-    AV_PIX_FMT_YUVJ444P,  ///< planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting color_range
     AV_PIX_FMT_UYVY422,   ///< packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
     AV_PIX_FMT_UYYVYY411, ///< packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
     AV_PIX_FMT_BGR8,      ///< packed RGB 3:3:2,  8bpp, (msb)2B 3G 3R(lsb)
@@ -97,7 +94,6 @@ enum AVPixelFormat {
     AV_PIX_FMT_GRAY16BE,  ///<        Y        , 16bpp, big-endian
     AV_PIX_FMT_GRAY16LE,  ///<        Y        , 16bpp, little-endian
     AV_PIX_FMT_YUV440P,   ///< planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
-    AV_PIX_FMT_YUVJ440P,  ///< planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
     AV_PIX_FMT_YUVA420P,  ///< planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
     AV_PIX_FMT_RGB48BE,   ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big-endian
     AV_PIX_FMT_RGB48LE,   ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as little-endian
@@ -273,7 +269,6 @@ enum AVPixelFormat {
     AV_PIX_FMT_GBRP12LE,    ///< planar GBR 4:4:4 36bpp, little-endian
     AV_PIX_FMT_GBRP14BE,    ///< planar GBR 4:4:4 42bpp, big-endian
     AV_PIX_FMT_GBRP14LE,    ///< planar GBR 4:4:4 42bpp, little-endian
-    AV_PIX_FMT_YUVJ411P,    ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV411P and setting color_range
 
     AV_PIX_FMT_BAYER_BGGR8,    ///< bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples
     AV_PIX_FMT_BAYER_RGGB8,    ///< bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples
diff --git a/libavutil/version.h b/libavutil/version.h
index 4c0c545d40..279e54c394 100644
--- a/libavutil/version.h
+++ b/libavutil/version.h
@@ -79,7 +79,7 @@
  */
 
 #define LIBAVUTIL_VERSION_MAJOR  58
-#define LIBAVUTIL_VERSION_MINOR  27
+#define LIBAVUTIL_VERSION_MINOR  28
 #define LIBAVUTIL_VERSION_MICRO 100
 
 #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
diff --git a/libswscale/utils.c b/libswscale/utils.c
index e1ad685972..c179ac05b5 100644
--- a/libswscale/utils.c
+++ b/libswscale/utils.c
@@ -78,10 +78,6 @@ static const FormatEntry format_entries[] = {
     [AV_PIX_FMT_MONOWHITE]   = { 1, 1 },
     [AV_PIX_FMT_MONOBLACK]   = { 1, 1 },
     [AV_PIX_FMT_PAL8]        = { 1, 0 },
-    [AV_PIX_FMT_YUVJ420P]    = { 1, 1 },
-    [AV_PIX_FMT_YUVJ411P]    = { 1, 1 },
-    [AV_PIX_FMT_YUVJ422P]    = { 1, 1 },
-    [AV_PIX_FMT_YUVJ444P]    = { 1, 1 },
     [AV_PIX_FMT_YVYU422]     = { 1, 1 },
     [AV_PIX_FMT_UYVY422]     = { 1, 1 },
     [AV_PIX_FMT_UYYVYY411]   = { 0, 0 },
@@ -112,7 +108,6 @@ static const FormatEntry format_entries[] = {
     [AV_PIX_FMT_GRAY16BE]    = { 1, 1 },
     [AV_PIX_FMT_GRAY16LE]    = { 1, 1 },
     [AV_PIX_FMT_YUV440P]     = { 1, 1 },
-    [AV_PIX_FMT_YUVJ440P]    = { 1, 1 },
     [AV_PIX_FMT_YUV440P10LE] = { 1, 1 },
     [AV_PIX_FMT_YUV440P10BE] = { 1, 1 },
     [AV_PIX_FMT_YUV440P12LE] = { 1, 1 },
@@ -928,21 +923,6 @@ static void fill_xyztables(struct SwsContext *c)
 static int handle_jpeg(enum AVPixelFormat *format)
 {
     switch (*format) {
-    case AV_PIX_FMT_YUVJ420P:
-        *format = AV_PIX_FMT_YUV420P;
-        return 1;
-    case AV_PIX_FMT_YUVJ411P:
-        *format = AV_PIX_FMT_YUV411P;
-        return 1;
-    case AV_PIX_FMT_YUVJ422P:
-        *format = AV_PIX_FMT_YUV422P;
-        return 1;
-    case AV_PIX_FMT_YUVJ444P:
-        *format = AV_PIX_FMT_YUV444P;
-        return 1;
-    case AV_PIX_FMT_YUVJ440P:
-        *format = AV_PIX_FMT_YUV440P;
-        return 1;
     case AV_PIX_FMT_GRAY8:
     case AV_PIX_FMT_YA8:
     case AV_PIX_FMT_GRAY9LE:
diff --git a/tests/fate/lavf-image.mak b/tests/fate/lavf-image.mak
index 4177e091b3..d6113f9071 100644
--- a/tests/fate/lavf-image.mak
+++ b/tests/fate/lavf-image.mak
@@ -72,7 +72,7 @@ fate-lavf-none.gbrapf32le.exr:  CMD = lavf_image "-compression none  -pix_fmt gb
 fate-lavf-rle.gbrapf32le.exr:   CMD = lavf_image "-compression rle   -pix_fmt gbrapf32le" "" "no_file_checksums"
 fate-lavf-zip1.gbrapf32le.exr:  CMD = lavf_image "-compression zip1  -pix_fmt gbrapf32le" "" "no_file_checksums"
 fate-lavf-zip16.gbrapf32le.exr: CMD = lavf_image "-compression zip16 -pix_fmt gbrapf32le" "" "no_file_checksums"
-fate-lavf-jpg: CMD = lavf_image "-pix_fmt yuvj420p"
+fate-lavf-jpg: CMD = lavf_image "-pix_fmt yuv420p"
 fate-lavf-tiff: CMD = lavf_image "-pix_fmt rgb24"
 fate-lavf-gbrp10le.dpx: CMD = lavf_image "-pix_fmt gbrp10le" "-pix_fmt gbrp10le"
 fate-lavf-gbrp12le.dpx: CMD = lavf_image "-pix_fmt gbrp12le" "-pix_fmt gbrp12le"
diff --git a/tests/fate/pixfmt.mak b/tests/fate/pixfmt.mak
index 715a4763d4..a637f27059 100644
--- a/tests/fate/pixfmt.mak
+++ b/tests/fate/pixfmt.mak
@@ -13,10 +13,6 @@ FATE_PIXFMT-$(CONFIG_SCALE_FILTER) =           bgr24           \
                         yuv422p         \
                         yuv440p         \
                         yuv444p         \
-                        yuvj420p        \
-                        yuvj422p        \
-                        yuvj440p        \
-                        yuvj444p        \
                         yuyv422         \
 
 FATE_PIXFMT := $(FATE_PIXFMT-yes:%=fate-pixfmt-%)
diff --git a/tests/fate/vcodec.mak b/tests/fate/vcodec.mak
index f7f474c146..166ddbba38 100644
--- a/tests/fate/vcodec.mak
+++ b/tests/fate/vcodec.mak
@@ -229,12 +229,12 @@ FATE_VCODEC-$(call ENCDEC, LJPEG MJPEG, AVI) += ljpeg
 fate-vsynth%-ljpeg:              ENCOPTS = -strict -1
 
 FATE_VCODEC_SCALE-$(call ENCDEC, MJPEG, AVI) += mjpeg mjpeg-422 mjpeg-444 mjpeg-trell mjpeg-huffman mjpeg-trell-huffman
-fate-vsynth%-mjpeg:                   ENCOPTS = -qscale 9 -pix_fmt yuvj420p
-fate-vsynth%-mjpeg-422:               ENCOPTS = -qscale 9 -pix_fmt yuvj422p
-fate-vsynth%-mjpeg-444:               ENCOPTS = -qscale 9 -pix_fmt yuvj444p
-fate-vsynth%-mjpeg-trell:             ENCOPTS = -qscale 9 -pix_fmt yuvj420p -trellis 1
-fate-vsynth%-mjpeg-huffman:           ENCOPTS = -qscale 9 -pix_fmt yuvj420p -huffman optimal
-fate-vsynth%-mjpeg-trell-huffman:     ENCOPTS = -qscale 9 -pix_fmt yuvj420p -trellis 1 -huffman optimal
+fate-vsynth%-mjpeg:                   ENCOPTS = -qscale 9 -pix_fmt yuv420p
+fate-vsynth%-mjpeg-422:               ENCOPTS = -qscale 9 -pix_fmt yuv422p
+fate-vsynth%-mjpeg-444:               ENCOPTS = -qscale 9 -pix_fmt yuv444p
+fate-vsynth%-mjpeg-trell:             ENCOPTS = -qscale 9 -pix_fmt yuv420p -trellis 1
+fate-vsynth%-mjpeg-huffman:           ENCOPTS = -qscale 9 -pix_fmt yuv420p -huffman optimal
+fate-vsynth%-mjpeg-trell-huffman:     ENCOPTS = -qscale 9 -pix_fmt yuv420p -trellis 1 -huffman optimal
 
 FATE_VCODEC-$(call ENCDEC, MPEG1VIDEO, MPEG1VIDEO MPEGVIDEO) += mpeg1 mpeg1b
 fate-vsynth%-mpeg1:              FMT     = mpeg1video
diff --git a/tests/ref/fate/exif-image-embedded b/tests/ref/fate/exif-image-embedded
index d5937e9f86..3311d90132 100644
--- a/tests/ref/fate/exif-image-embedded
+++ b/tests/ref/fate/exif-image-embedded
@@ -20,7 +20,7 @@ crop_top=0
 crop_bottom=0
 crop_left=0
 crop_right=0
-pix_fmt=yuvj420p
+pix_fmt=yuv420p
 sample_aspect_ratio=1:1
 pict_type=I
 coded_picture_number=0
diff --git a/tests/ref/fate/exif-image-jpg b/tests/ref/fate/exif-image-jpg
index bed265b717..8d1bbe42e7 100644
--- a/tests/ref/fate/exif-image-jpg
+++ b/tests/ref/fate/exif-image-jpg
@@ -20,7 +20,7 @@ crop_top=0
 crop_bottom=0
 crop_left=0
 crop_right=0
-pix_fmt=yuvj422p
+pix_fmt=yuv422p
 sample_aspect_ratio=1:1
 pict_type=I
 coded_picture_number=0
diff --git a/tests/ref/fate/filter-pixfmts-copy b/tests/ref/fate/filter-pixfmts-copy
index eb3e61b4f2..e4864dfc7a 100644
--- a/tests/ref/fate/filter-pixfmts-copy
+++ b/tests/ref/fate/filter-pixfmts-copy
@@ -175,10 +175,5 @@ yuva444p16be        c80c1899789a6411d0025730efc8f01c
 yuva444p16le        2ed56ea50fafda4d226c9b133755dad8
 yuva444p9be         4903fde22b15d28da90761ac1cfcb1c5
 yuva444p9le         4eeb5988df0740fea720da1e31bbb829
-yuvj411p            e003eefa7e2a20f20d33767775417216
-yuvj420p            8f3d8f1b4577d11082d5ab8a901e048d
-yuvj422p            79d480e99e610112f266c833c6cb3d35
-yuvj440p            f4b18310c7174868fc92579f87460876
-yuvj444p            b161e6d5a941e2a4bb7bc56ef8af623f
 yuyv422             435c92283b538aa3d8fa2a020b0afd49
 yvyu422             8436c2a760291cc979e0dd62ab8cede0
diff --git a/tests/ref/fate/filter-pixfmts-crop b/tests/ref/fate/filter-pixfmts-crop
index 01cb88bc54..9a2f8aa920 100644
--- a/tests/ref/fate/filter-pixfmts-crop
+++ b/tests/ref/fate/filter-pixfmts-crop
@@ -170,8 +170,3 @@ yuva444p16be        f817caf234aaf5848b2bc9679582ed56
 yuva444p16le        b32ad623fc423f897ff31c4073ea2a6f
 yuva444p9be         48498d994c3c9070f31773e39da306dd
 yuva444p9le         431b0ac211a8f81c15f38fb57a73530c
-yuvj411p            241d393eeaa1517f6b4b23034222994b
-yuvj420p            35583968261c636b9c57ff03fd60eb54
-yuvj422p            c29a94439e96cd5dab7f65eb6dfc2f5c
-yuvj440p            8899d4ce717e32937d58a76df473ba7a
-yuvj444p            6c0d0ad629baaa96fe4dcb00f0f5d9de
diff --git a/tests/ref/fate/filter-pixfmts-field b/tests/ref/fate/filter-pixfmts-field
index c7d9b8f133..3cb9480b0f 100644
--- a/tests/ref/fate/filter-pixfmts-field
+++ b/tests/ref/fate/filter-pixfmts-field
@@ -175,10 +175,5 @@ yuva444p16be        b10fd7c1b61ac22bdb285f0d91a390f1
 yuva444p16le        cac82ffc36b7052747407663fc5ed510
 yuva444p9be         a6f66d08b3370fdd90987a6143b7b91c
 yuva444p9le         8d0f0b0840096127613920984078ce53
-yuvj411p            0c7caab687fbd33cba04702366b6c401
-yuvj420p            c9bef7e5c1dba1024be992167806ef07
-yuvj422p            ac900a0f9854dc2a0ec2e016ff5487dc
-yuvj440p            6f0d66982a3b96efb341a512314317ca
-yuvj444p            d559f8cf2e68b0cd3abadbb2f3642dd7
 yuyv422             449ca8d4b5a28ccaaa342860b24aeb3c
 yvyu422             6b226a0d4fce5478294d3bd4ecfb46a5
diff --git a/tests/ref/fate/filter-pixfmts-fieldorder b/tests/ref/fate/filter-pixfmts-fieldorder
index 2f64bd3b14..b9a9ef6dfe 100644
--- a/tests/ref/fate/filter-pixfmts-fieldorder
+++ b/tests/ref/fate/filter-pixfmts-fieldorder
@@ -140,8 +140,5 @@ yuva444p16be        2f80d411847856e1364659dee8b23485
 yuva444p16le        5796be8d66371b60037fc8053c27e900
 yuva444p9be         a83599c0e9fca08f6b7c6e02c2413fcf
 yuva444p9le         390fcd8f72ee407a8c338667944e3f72
-yuvj411p            73fa99cb96d2f7171bff15bc2e43d963
-yuvj422p            d5e67ce1db5347cf3416069286359f57
-yuvj444p            e915da6b5aa0ee5298771ba0ca187cad
 yuyv422             a923c5bd4889bec92d872237f6a578ec
 yvyu422             d7a8697f1f5e6a2a27b0df17811b2613
diff --git a/tests/ref/fate/filter-pixfmts-hflip b/tests/ref/fate/filter-pixfmts-hflip
index 66274890a7..77c127ea54 100644
--- a/tests/ref/fate/filter-pixfmts-hflip
+++ b/tests/ref/fate/filter-pixfmts-hflip
@@ -170,8 +170,3 @@ yuva444p16be        635fb2720470e0042a7c9b70bf908a2c
 yuva444p16le        6d5bd13f8bb804bd1158c1af732a24e1
 yuva444p9be         3d3e7491192aa4e396015bf8e3755a24
 yuva444p9le         31727b34bc3d5ce726681e90557d39e4
-yuvj411p            70a0abb56a538376aff33c275584b61e
-yuvj420p            83af439c504d41f986adc17059b7fda8
-yuvj422p            daf02a72b26d17d1855b977aa04609fb
-yuvj440p            a4af7a9e3cff6cfc1c8924590ae69807
-yuvj444p            f5937e0183439411673d2ebf8df62e2b
diff --git a/tests/ref/fate/filter-pixfmts-il b/tests/ref/fate/filter-pixfmts-il
index 03519f2a9d..415ccc7307 100644
--- a/tests/ref/fate/filter-pixfmts-il
+++ b/tests/ref/fate/filter-pixfmts-il
@@ -174,10 +174,5 @@ yuva444p16be        97f8cb6ed835c7c5cd2fb112b1e135c7
 yuva444p16le        47170401a8c348d3f05f6530607d066b
 yuva444p9be         d5c0170b41221a9607e6ae586880a383
 yuva444p9le         4948983313f46180666dec85ef30130c
-yuvj411p            91e137f54b2cbbb1c1423c36f031d5f2
-yuvj420p            2b6d8e3b527af5de94963d1bdefe20a9
-yuvj422p            4ce16aa04a5e785b29fd9cdf54bc9ca1
-yuvj440p            36a248ec6f1dc67555ee590651388b15
-yuvj444p            279790fe3c83b07f0a09085d36849c30
 yuyv422             09af5b85deecfeaef2e00e00fbc12a49
 yvyu422             62c62a80939c34fb7890c0e7791a0321
diff --git a/tests/ref/fate/filter-pixfmts-lut b/tests/ref/fate/filter-pixfmts-lut
index 41c66e2bfc..fd4d1bc4b3 100644
--- a/tests/ref/fate/filter-pixfmts-lut
+++ b/tests/ref/fate/filter-pixfmts-lut
@@ -51,7 +51,3 @@ yuva422p            5938a7c7588febb069bd0cd4c447305e
 yuva422p16le        c5ccfdc1a0dc6cb130c07ea61df6f727
 yuva444p            fbcbdc3521d17c702ee521b0893098e4
 yuva444p16le        b7142d28d4d069d7eb019dcaf8b323b1
-yuvj420p            65bc88887c7f06a6221155ca7f9cfca4
-yuvj422p            ff5baffefc8ffe4547653092fd7da200
-yuvj440p            ef3f27270e60ac06582e3ac7c2f3e6fa
-yuvj444p            29378d3fd132c760522c51c3378067b8
diff --git a/tests/ref/fate/filter-pixfmts-null b/tests/ref/fate/filter-pixfmts-null
index eb3e61b4f2..e4864dfc7a 100644
--- a/tests/ref/fate/filter-pixfmts-null
+++ b/tests/ref/fate/filter-pixfmts-null
@@ -175,10 +175,5 @@ yuva444p16be        c80c1899789a6411d0025730efc8f01c
 yuva444p16le        2ed56ea50fafda4d226c9b133755dad8
 yuva444p9be         4903fde22b15d28da90761ac1cfcb1c5
 yuva444p9le         4eeb5988df0740fea720da1e31bbb829
-yuvj411p            e003eefa7e2a20f20d33767775417216
-yuvj420p            8f3d8f1b4577d11082d5ab8a901e048d
-yuvj422p            79d480e99e610112f266c833c6cb3d35
-yuvj440p            f4b18310c7174868fc92579f87460876
-yuvj444p            b161e6d5a941e2a4bb7bc56ef8af623f
 yuyv422             435c92283b538aa3d8fa2a020b0afd49
 yvyu422             8436c2a760291cc979e0dd62ab8cede0
diff --git a/tests/ref/fate/filter-pixfmts-pad b/tests/ref/fate/filter-pixfmts-pad
index dd01059c59..d04f7ddd3f 100644
--- a/tests/ref/fate/filter-pixfmts-pad
+++ b/tests/ref/fate/filter-pixfmts-pad
@@ -83,8 +83,3 @@ yuva444p10le        89491ef450706faf23341e401750d907
 yuva444p12le        06c47dba21328165dbb7ebb3da0a2fde
 yuva444p16le        d089b119c8dc964de9af12bfb38f89a0
 yuva444p9le         b824d34ac49a1dc483c772e15310afcd
-yuvj411p            87dbac57b211ab4823c1abbd702f1516
-yuvj420p            1abef62bce65131ca4913eb2006fd860
-yuvj422p            198c57b519e2be14b150889bd7f94898
-yuvj440p            e6533260d197ad15e39319117c57473e
-yuvj444p            26a44748960513783ea676eff409d89a
diff --git a/tests/ref/fate/filter-pixfmts-pullup b/tests/ref/fate/filter-pixfmts-pullup
index c6ddb3489a..d2f927a0c9 100644
--- a/tests/ref/fate/filter-pixfmts-pullup
+++ b/tests/ref/fate/filter-pixfmts-pullup
@@ -5,8 +5,3 @@ yuv420p             dba6303cd02cc39cb0db7b546793d565
 yuv422p             d7d3224dd900bb1b96608a28a704360d
 yuv440p             d4c5f20701cfceb4bbf7d75cfcc13514
 yuv444p             7e405274037e7f2ab845d7413a71e16d
-yuvj411p            dc602e7bd3449d16e17e695815616b1e
-yuvj420p            b98ec86eeef2d512aeb2fc4d32ffa656
-yuvj422p            f09c3240bb662477b76ce4da34b4feed
-yuvj440p            8d3ab69e2bbbbbd2f9be323c18922533
-yuvj444p            2dc27560eed5d685354796dcccce853c
diff --git a/tests/ref/fate/filter-pixfmts-rotate b/tests/ref/fate/filter-pixfmts-rotate
index e4ed81e71a..3aa21aff77 100644
--- a/tests/ref/fate/filter-pixfmts-rotate
+++ b/tests/ref/fate/filter-pixfmts-rotate
@@ -30,5 +30,3 @@ yuva444p            459fad5abfd16db9bb6a52761dc74cc1
 yuva444p10le        92f820d3481b7ebcb48b98a73e7b4c90
 yuva444p16le        2ed56ea50fafda4d226c9b133755dad8
 yuva444p9le         4eeb5988df0740fea720da1e31bbb829
-yuvj420p            8f3d8f1b4577d11082d5ab8a901e048d
-yuvj444p            b161e6d5a941e2a4bb7bc56ef8af623f
diff --git a/tests/ref/fate/filter-pixfmts-scale b/tests/ref/fate/filter-pixfmts-scale
index b11384068b..13f885a6a6 100644
--- a/tests/ref/fate/filter-pixfmts-scale
+++ b/tests/ref/fate/filter-pixfmts-scale
@@ -175,10 +175,5 @@ yuva444p16be        39ca2e32aa61b210b6c528855d24a16b
 yuva444p16le        cd2e0a001d8175f2204b2eb411c6a801
 yuva444p9be         58add24afbf43ff0ff7079cc1948fb56
 yuva444p9le         077c8cec2c374163d7f7eae27e797bdb
-yuvj411p            d1076331c75ca66bf62497edbd8384f9
-yuvj420p            10390e6dda9cbb4c61fb88bcbb49fc3c
-yuvj422p            996f6672566a4dcd8d272f48f058d49e
-yuvj440p            3d80c9f67f8ef9b2d8a9ae2d37b464a2
-yuvj444p            9f858b9ca3fe949611147414573a904f
 yuyv422             1704675eff94ad0a03a9a6a3ddf5e0df
 yvyu422             516705a40f43d00e9c41ff47f4f7b802
diff --git a/tests/ref/fate/filter-pixfmts-swapuv b/tests/ref/fate/filter-pixfmts-swapuv
index 676a440699..bf6e5c08c3 100644
--- a/tests/ref/fate/filter-pixfmts-swapuv
+++ b/tests/ref/fate/filter-pixfmts-swapuv
@@ -63,8 +63,3 @@ yuva444p16be        356d72791dfd91861b21630e315d40cb
 yuva444p16le        176591ce074ba8befc5fb279446ca1be
 yuva444p9be         675f0ed3e6572b05f06d9e44611bdff5
 yuva444p9le         bf3ea2bf123a3a1ceedf587682b85cb9
-yuvj411p            361c32e086bd27cf3ded194dc00dc9c5
-yuvj420p            553ac1af571391271d9715e2e8a4a5cc
-yuvj422p            39b613d01cacfcdd9eecf9e0d379a393
-yuvj440p            afed4ad98d6accf5811d439f3a687aa1
-yuvj444p            8de64aff4b7b3895d8cedd67cc10722b
diff --git a/tests/ref/fate/filter-pixfmts-tinterlace_cvlpf b/tests/ref/fate/filter-pixfmts-tinterlace_cvlpf
index 99703fa1af..df269b9a7c 100644
--- a/tests/ref/fate/filter-pixfmts-tinterlace_cvlpf
+++ b/tests/ref/fate/filter-pixfmts-tinterlace_cvlpf
@@ -19,7 +19,3 @@ yuva422p            a8da2806e21a88449079faa7f4303ffa
 yuva422p10le        d2965b5b5a43a7165badaff0718a17d8
 yuva444p            a3f57734d6f72bdf37f8f612ea7cce63
 yuva444p10le        e020512901fd9ac7088898a4e3a8c7c1
-yuvj420p            9f358e311b694bcd01e1a07d1120ade5
-yuvj422p            9a7628a9f1630d35c7176951ddc1b2f6
-yuvj440p            112fe35292c687746ec0c622a42c611b
-yuvj444p            f894438f40950229baa02545daa8812a
diff --git a/tests/ref/fate/filter-pixfmts-tinterlace_merge b/tests/ref/fate/filter-pixfmts-tinterlace_merge
index fa6151c272..7b0026faee 100644
--- a/tests/ref/fate/filter-pixfmts-tinterlace_merge
+++ b/tests/ref/fate/filter-pixfmts-tinterlace_merge
@@ -19,7 +19,3 @@ yuva422p            ca200be80e5bfdb159e1aea57129ed3a
 yuva422p10le        06d4f79ee2ddf31d9fe15af8ca573f46
 yuva444p            9f39c35d6899dcb8b9a9b07c339ca365
 yuva444p10le        b0c54fc3efad73f252d86127407aa1fd
-yuvj420p            844359293bb6ff81549f3fc0090cc587
-yuvj422p            526af049d43974822baa7b48aa1e1098
-yuvj440p            af9285194da8efbc40d93bf8109f9dc5
-yuvj444p            2a3f18b02c17a0c39c6245b8b3639b91
diff --git a/tests/ref/fate/filter-pixfmts-tinterlace_pad b/tests/ref/fate/filter-pixfmts-tinterlace_pad
index 29321e542b..5cf2bc95dd 100644
--- a/tests/ref/fate/filter-pixfmts-tinterlace_pad
+++ b/tests/ref/fate/filter-pixfmts-tinterlace_pad
@@ -19,7 +19,3 @@ yuva422p            3426ed1ac9429202d8c29fa62a04d4c3
 yuva422p10le        5c62eaf71afec3f7bc7ae5a327431434
 yuva444p            1b9fc791c7d774b4ba8c9dc836f78cf5
 yuva444p10le        b6161c0f6f5548ba4346a9fda20ea8a8
-yuvj420p            9a872e0c1b3c0b6fe856415696b758bd
-yuvj422p            da3c9ef25528a2ee96746ce44e6969f3
-yuvj440p            a9a5495c6b0e2bf6e561998ea1c356a7
-yuvj444p            085214844e83ad47b4f33303db0ebee6
diff --git a/tests/ref/fate/filter-pixfmts-tinterlace_vlpf b/tests/ref/fate/filter-pixfmts-tinterlace_vlpf
index 5a5f80b115..0f64dd882c 100644
--- a/tests/ref/fate/filter-pixfmts-tinterlace_vlpf
+++ b/tests/ref/fate/filter-pixfmts-tinterlace_vlpf
@@ -19,7 +19,3 @@ yuva422p            ef8fdbe910d68e88e98227b0e99fb5a6
 yuva422p10le        257a4aec41f9b5412179272d8a7fb6f7
 yuva444p            3662eadd5f61a6edbc9d715ea8591415
 yuva444p10le        0905cf5b7f42c11be3f0486a66533c71
-yuvj420p            14c4390b319c5d679184503309060ac3
-yuvj422p            bbe00a26526931b72a024febe1cd6b90
-yuvj440p            f654cf28b7879c6a6c950c3cb9612580
-yuvj444p            c162a4fe7a665f4abf257443703f0d72
diff --git a/tests/ref/fate/filter-pixfmts-transpose b/tests/ref/fate/filter-pixfmts-transpose
index ec157dee0c..9d0d9df86d 100644
--- a/tests/ref/fate/filter-pixfmts-transpose
+++ b/tests/ref/fate/filter-pixfmts-transpose
@@ -136,5 +136,3 @@ yuva444p16be        9fd2f00ea9bef8e488228bc0b47b28cb
 yuva444p16le        ae9fd8d1baea0f8626b963816d667d2d
 yuva444p9be         4ce11ae57780f74c78cdd5c06be4bded
 yuva444p9le         1b9cc85fd6ab0c7e240915a99e98d1c1
-yuvj420p            9603b8dd64daec41f0514197989c2b19
-yuvj444p            66ec9b3219df9eb2c1315d293602ab42
diff --git a/tests/ref/fate/filter-pixfmts-vflip b/tests/ref/fate/filter-pixfmts-vflip
index 9a7972d6cf..53f6b76f66 100644
--- a/tests/ref/fate/filter-pixfmts-vflip
+++ b/tests/ref/fate/filter-pixfmts-vflip
@@ -175,10 +175,5 @@ yuva444p16be        b8801dccf64b3eadc2a5b5db67ae0b0f
 yuva444p16le        8e72ae66754badf5d1eeb094e6bf0ddc
 yuva444p9be         bcd845394351ca6d15e947342802957d
 yuva444p9le         7727a93765ed38dfd25e3d6b7a38fa63
-yuvj411p            260f51b360dc00b2222f4cb39fa05e36
-yuvj420p            fab4394239b08bdb7638215a42d56eaf
-yuvj422p            0309c2b34aa4d74f58048fe320a02b83
-yuvj440p            f5e3a92fa46e57e2c613fc9aaad18e9d
-yuvj444p            ca4b3662259ba15a6297a44ef64414b7
 yuyv422             8f02b2332fe9bb782f88627c99f32ee8
 yvyu422             bd8cb985c2e1f9c32dc6b865bdf20637
diff --git a/tests/ref/fate/imgutils b/tests/ref/fate/imgutils
index f166cb67fb..94b274d831 100644
--- a/tests/ref/fate/imgutils
+++ b/tests/ref/fate/imgutils
@@ -66,9 +66,6 @@ gray            planes: 1, linesizes:  64   0   0   0, plane_sizes:  3072     0
 monow           planes: 1, linesizes:   8   0   0   0, plane_sizes:   384     0     0     0, plane_offsets:     0     0     0, total_size: 384
 monob           planes: 1, linesizes:   8   0   0   0, plane_sizes:   384     0     0     0, plane_offsets:     0     0     0, total_size: 384
 pal8            planes: 2, linesizes:  64   0   0   0, plane_sizes:  3072  1024     0     0, plane_offsets:  3072     0     0, total_size: 4096
-yuvj420p        planes: 3, linesizes:  64  32  32   0, plane_sizes:  3072   768   768     0, plane_offsets:  3072   768     0, total_size: 4608
-yuvj422p        planes: 3, linesizes:  64  32  32   0, plane_sizes:  3072  1536  1536     0, plane_offsets:  3072  1536     0, total_size: 6144
-yuvj444p        planes: 3, linesizes:  64  64  64   0, plane_sizes:  3072  3072  3072     0, plane_offsets:  3072  3072     0, total_size: 9216
 uyvy422         planes: 1, linesizes: 128   0   0   0, plane_sizes:  6144     0     0     0, plane_offsets:     0     0     0, total_size: 6144
 uyyvyy411       planes: 1, linesizes:  96   0   0   0, plane_sizes:  4608     0     0     0, plane_offsets:     0     0     0, total_size: 4608
 bgr8            planes: 1, linesizes:  64   0   0   0, plane_sizes:  3072     0     0     0, plane_offsets:     0     0     0, total_size: 3072
@@ -86,7 +83,6 @@ bgra            planes: 1, linesizes: 256   0   0   0, plane_sizes: 12288     0
 gray16be        planes: 1, linesizes: 128   0   0   0, plane_sizes:  6144     0     0     0, plane_offsets:     0     0     0, total_size: 6144
 gray16le        planes: 1, linesizes: 128   0   0   0, plane_sizes:  6144     0     0     0, plane_offsets:     0     0     0, total_size: 6144
 yuv440p         planes: 3, linesizes:  64  64  64   0, plane_sizes:  3072  1536  1536     0, plane_offsets:  3072  1536     0, total_size: 6144
-yuvj440p        planes: 3, linesizes:  64  64  64   0, plane_sizes:  3072  1536  1536     0, plane_offsets:  3072  1536     0, total_size: 6144
 yuva420p        planes: 4, linesizes:  64  32  32  64, plane_sizes:  3072   768   768  3072, plane_offsets:  3072   768   768, total_size: 7680
 rgb48be         planes: 1, linesizes: 384   0   0   0, plane_sizes: 18432     0     0     0, plane_offsets:     0     0     0, total_size: 18432
 rgb48le         planes: 1, linesizes: 384   0   0   0, plane_sizes: 18432     0     0     0, plane_offsets:     0     0     0, total_size: 18432
@@ -185,7 +181,6 @@ gbrp12be        planes: 3, linesizes: 128 128 128   0, plane_sizes:  6144  6144
 gbrp12le        planes: 3, linesizes: 128 128 128   0, plane_sizes:  6144  6144  6144     0, plane_offsets:  6144  6144     0, total_size: 18432
 gbrp14be        planes: 3, linesizes: 128 128 128   0, plane_sizes:  6144  6144  6144     0, plane_offsets:  6144  6144     0, total_size: 18432
 gbrp14le        planes: 3, linesizes: 128 128 128   0, plane_sizes:  6144  6144  6144     0, plane_offsets:  6144  6144     0, total_size: 18432
-yuvj411p        planes: 3, linesizes:  64  16  16   0, plane_sizes:  3072   768   768     0, plane_offsets:  3072   768     0, total_size: 4608
 bayer_bggr8     planes: 1, linesizes:  64   0   0   0, plane_sizes:  3072     0     0     0, plane_offsets:     0     0     0, total_size: 3072
 bayer_rggb8     planes: 1, linesizes:  64   0   0   0, plane_sizes:  3072     0     0     0, plane_offsets:     0     0     0, total_size: 3072
 bayer_gbrg8     planes: 1, linesizes:  64   0   0   0, plane_sizes:  3072     0     0     0, plane_offsets:     0     0     0, total_size: 3072
diff --git a/tests/ref/fate/jpg-icc b/tests/ref/fate/jpg-icc
index cc7ab604e1..41494e3383 100644
--- a/tests/ref/fate/jpg-icc
+++ b/tests/ref/fate/jpg-icc
@@ -28,7 +28,7 @@ crop_top=0
 crop_bottom=0
 crop_left=0
 crop_right=0
-pix_fmt=yuvj444p
+pix_fmt=yuv444p
 sample_aspect_ratio=1:1
 pict_type=I
 coded_picture_number=0
diff --git a/tests/ref/fate/sws-pixdesc-query b/tests/ref/fate/sws-pixdesc-query
index fff93bbf0e..58283b4430 100644
--- a/tests/ref/fate/sws-pixdesc-query
+++ b/tests/ref/fate/sws-pixdesc-query
@@ -327,11 +327,6 @@ isYUV:
   yuva444p16le
   yuva444p9be
   yuva444p9le
-  yuvj411p
-  yuvj420p
-  yuvj422p
-  yuvj440p
-  yuvj444p
   yuyv422
   yvyu422
 
@@ -426,11 +421,6 @@ isPlanarYUV:
   yuva444p16le
   yuva444p9be
   yuva444p9le
-  yuvj411p
-  yuvj420p
-  yuvj422p
-  yuvj440p
-  yuvj444p
 
 isSemiPlanarYUV:
   nv12
@@ -957,11 +947,6 @@ Planar:
   yuva444p16le
   yuva444p9be
   yuva444p9le
-  yuvj411p
-  yuvj420p
-  yuvj422p
-  yuvj440p
-  yuvj444p
 
 PackedRGB:
   0bgr
-- 
2.42.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 v2 11/13] swscale/utils: simplify JPEG handling function

[Niklas Haas]

From: Niklas Haas <git@haasn.dev>

YUVJ no longer exists, so this is now just a check for luma-only
formats, and no longer needs to mutate the pixel format.
---
 libswscale/utils.c | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/libswscale/utils.c b/libswscale/utils.c
index c179ac05b5..0a4b969fec 100644
--- a/libswscale/utils.c
+++ b/libswscale/utils.c
@@ -920,9 +920,9 @@ static void fill_xyztables(struct SwsContext *c)
     }
 }
 
-static int handle_jpeg(enum AVPixelFormat *format)
+static int is_luma_only(enum AVPixelFormat format)
 {
-    switch (*format) {
+    switch (format) {
     case AV_PIX_FMT_GRAY8:
     case AV_PIX_FMT_YA8:
     case AV_PIX_FMT_GRAY9LE:
@@ -2018,7 +2018,6 @@ av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter,
                              SwsFilter *dstFilter)
 {
     static AVOnce rgb2rgb_once = AV_ONCE_INIT;
-    enum AVPixelFormat src_format, dst_format;
     int ret;
 
     c->frame_src = av_frame_alloc();
@@ -2029,13 +2028,8 @@ av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter,
     if (ff_thread_once(&rgb2rgb_once, ff_sws_rgb2rgb_init) != 0)
         return AVERROR_UNKNOWN;
 
-    src_format = c->srcFormat;
-    dst_format = c->dstFormat;
-    c->srcRange |= handle_jpeg(&c->srcFormat);
-    c->dstRange |= handle_jpeg(&c->dstFormat);
-
-    if (src_format != c->srcFormat || dst_format != c->dstFormat)
-        av_log(c, AV_LOG_WARNING, "deprecated pixel format used, make sure you did set range correctly\n");
+    c->srcRange |= is_luma_only(c->srcFormat);
+    c->dstRange |= is_luma_only(c->dstFormat);
 
     if (c->nb_threads != 1) {
         ret = context_init_threaded(c, srcFilter, dstFilter);
-- 
2.42.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 v2 12/13] tests/fate: remove unused YUVJ ref files

[Niklas Haas]

From: Niklas Haas <git@haasn.dev>

---
 tests/ref/fate/filter-pixdesc-yuvj411p | 1 -
 tests/ref/fate/filter-pixdesc-yuvj420p | 1 -
 tests/ref/fate/filter-pixdesc-yuvj422p | 1 -
 tests/ref/fate/filter-pixdesc-yuvj440p | 1 -
 tests/ref/fate/filter-pixdesc-yuvj444p | 1 -
 tests/ref/pixfmt/yuvj420p              | 2 --
 tests/ref/pixfmt/yuvj422p              | 2 --
 tests/ref/pixfmt/yuvj440p              | 2 --
 tests/ref/pixfmt/yuvj444p              | 2 --
 9 files changed, 13 deletions(-)
 delete mode 100644 tests/ref/fate/filter-pixdesc-yuvj411p
 delete mode 100644 tests/ref/fate/filter-pixdesc-yuvj420p
 delete mode 100644 tests/ref/fate/filter-pixdesc-yuvj422p
 delete mode 100644 tests/ref/fate/filter-pixdesc-yuvj440p
 delete mode 100644 tests/ref/fate/filter-pixdesc-yuvj444p
 delete mode 100644 tests/ref/pixfmt/yuvj420p
 delete mode 100644 tests/ref/pixfmt/yuvj422p
 delete mode 100644 tests/ref/pixfmt/yuvj440p
 delete mode 100644 tests/ref/pixfmt/yuvj444p

diff --git a/tests/ref/fate/filter-pixdesc-yuvj411p b/tests/ref/fate/filter-pixdesc-yuvj411p
deleted file mode 100644
index 5dfc0dc4cd..0000000000
--- a/tests/ref/fate/filter-pixdesc-yuvj411p
+++ /dev/null
@@ -1 +0,0 @@
-pixdesc-yuvj411p    cac93399031ad86e8de0796b60b5bb8a
diff --git a/tests/ref/fate/filter-pixdesc-yuvj420p b/tests/ref/fate/filter-pixdesc-yuvj420p
deleted file mode 100644
index ad2f968a1f..0000000000
--- a/tests/ref/fate/filter-pixdesc-yuvj420p
+++ /dev/null
@@ -1 +0,0 @@
-pixdesc-yuvj420p    5244374882cf07c3cbcde71940caf8e5
diff --git a/tests/ref/fate/filter-pixdesc-yuvj422p b/tests/ref/fate/filter-pixdesc-yuvj422p
deleted file mode 100644
index 5f80d585d6..0000000000
--- a/tests/ref/fate/filter-pixdesc-yuvj422p
+++ /dev/null
@@ -1 +0,0 @@
-pixdesc-yuvj422p    6c9722aa9e0c1b8f9d953efeb93dc318
diff --git a/tests/ref/fate/filter-pixdesc-yuvj440p b/tests/ref/fate/filter-pixdesc-yuvj440p
deleted file mode 100644
index c98669285b..0000000000
--- a/tests/ref/fate/filter-pixdesc-yuvj440p
+++ /dev/null
@@ -1 +0,0 @@
-pixdesc-yuvj440p    34e6e86ca3ec4e6ef62d533aa2290e8f
diff --git a/tests/ref/fate/filter-pixdesc-yuvj444p b/tests/ref/fate/filter-pixdesc-yuvj444p
deleted file mode 100644
index 3e182fa6e2..0000000000
--- a/tests/ref/fate/filter-pixdesc-yuvj444p
+++ /dev/null
@@ -1 +0,0 @@
-pixdesc-yuvj444p    f67694103bb42d74742918adf9ea31c5
diff --git a/tests/ref/pixfmt/yuvj420p b/tests/ref/pixfmt/yuvj420p
deleted file mode 100644
index 47a729ed45..0000000000
--- a/tests/ref/pixfmt/yuvj420p
+++ /dev/null
@@ -1,2 +0,0 @@
-e176bd14185788110e055f945de7f95f *tests/data/pixfmt/yuvj420p.yuv
-304128 tests/data/pixfmt/yuvj420p.yuv
diff --git a/tests/ref/pixfmt/yuvj422p b/tests/ref/pixfmt/yuvj422p
deleted file mode 100644
index 6ab97d59db..0000000000
--- a/tests/ref/pixfmt/yuvj422p
+++ /dev/null
@@ -1,2 +0,0 @@
-472028e46a81c98d9b2477507def4723 *tests/data/pixfmt/yuvj422p.yuv
-304128 tests/data/pixfmt/yuvj422p.yuv
diff --git a/tests/ref/pixfmt/yuvj440p b/tests/ref/pixfmt/yuvj440p
deleted file mode 100644
index 2beeae52c1..0000000000
--- a/tests/ref/pixfmt/yuvj440p
+++ /dev/null
@@ -1,2 +0,0 @@
-4d8d402c45d913038d4b725396719111 *tests/data/pixfmt/yuvj440p.yuv
-304128 tests/data/pixfmt/yuvj440p.yuv
diff --git a/tests/ref/pixfmt/yuvj444p b/tests/ref/pixfmt/yuvj444p
deleted file mode 100644
index 63fb813d4b..0000000000
--- a/tests/ref/pixfmt/yuvj444p
+++ /dev/null
@@ -1,2 +0,0 @@
-c10442da177c9f1d12be3c53be6fa12c *tests/data/pixfmt/yuvj444p.yuv
-304128 tests/data/pixfmt/yuvj444p.yuv
-- 
2.42.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 v2 13/13] avutil/pixdesc: remove old yuvj pixel format check

[Niklas Haas]

From: Niklas Haas <git@haasn.dev>

These no longer exist.
---
 libavutil/pixdesc.c | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)

diff --git a/libavutil/pixdesc.c b/libavutil/pixdesc.c
index d640624aaf..75b1ae3cea 100644
--- a/libavutil/pixdesc.c
+++ b/libavutil/pixdesc.c
@@ -2977,8 +2977,7 @@ enum AVPixelFormat av_pix_fmt_swap_endianness(enum AVPixelFormat pix_fmt)
 #define FF_COLOR_NA      -1
 #define FF_COLOR_RGB      0 /**< RGB color space */
 #define FF_COLOR_GRAY     1 /**< gray color space */
-#define FF_COLOR_YUV      2 /**< YUV color space. 16 <= Y <= 235, 16 <= U, V <= 240 */
-#define FF_COLOR_YUV_JPEG 3 /**< YUV color space. 0 <= Y <= 255, 0 <= U, V <= 255 */
+#define FF_COLOR_YUV      2 /**< YUV color space */
 #define FF_COLOR_XYZ      4
 
 #define pixdesc_has_alpha(pixdesc) \
@@ -2993,9 +2992,6 @@ static int get_color_type(const AVPixFmtDescriptor *desc) {
         return FF_COLOR_GRAY;
 
     if (desc->name) {
-        if (av_strstart(desc->name, "yuvj", NULL))
-            return FF_COLOR_YUV_JPEG;
-
         if (av_strstart(desc->name, "xyz", NULL))
             return FF_COLOR_XYZ;
     }
@@ -3135,12 +3131,6 @@ static int get_pix_fmt_score(enum AVPixelFormat dst_pix_fmt,
         if (src_color != FF_COLOR_YUV)
             loss |= FF_LOSS_COLORSPACE;
         break;
-    case FF_COLOR_YUV_JPEG:
-        if (src_color != FF_COLOR_YUV_JPEG &&
-            src_color != FF_COLOR_YUV &&
-            src_color != FF_COLOR_GRAY)
-            loss |= FF_LOSS_COLORSPACE;
-        break;
     default:
         /* fail safe test */
         if (src_color != dst_color)
-- 
2.42.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 v2 00/13] YUVJ removal

[Vittorio Giovara]

On Fri, Oct 13, 2023 at 10:27 AM Niklas Haas <ffmpeg@haasn.xyz> wrote:

> Changes since v1:
>
> - Remove unneeded patch (AVCodecContext.colorspace init)
> - Merge auto-range conversion into auto-scale filter
> - Replace vf_zscale by vf_colorspace in fftools
>

Why is this? I haven't checked what vf_colorspace supports in a hot second,
but iirc zscale can handle non linear spaces better and hdr conversion
If it's because it's a built in filter, do you think we could first check
for zscale presence and fallback to colorspace?

- Add some miscellaneous fixes for various FATE tests
> - Clean up some additional vestigiaul YUVJ remnants
>
-- 
Vittorio
_______________________________________________
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 v2 00/13] YUVJ removal

[Lynne]

Oct 13, 2023, 20:33 by vittorio.giovara@gmail.com:

> On Fri, Oct 13, 2023 at 10:27 AM Niklas Haas <ffmpeg@haasn.xyz> wrote:
>
>> Changes since v1:
>>
>> - Remove unneeded patch (AVCodecContext.colorspace init)
>> - Merge auto-range conversion into auto-scale filter
>> - Replace vf_zscale by vf_colorspace in fftools
>>
>
> Why is this? I haven't checked what vf_colorspace supports in a hot second,
> but iirc zscale can handle non linear spaces better and hdr conversion
> If it's because it's a built in filter, do you think we could first check
> for zscale presence and fallback to colorspace?
>

vf_colorspace != swscale

Relying on external library for basic functionality that we have
no control over, which may break its ABI or API at any moment,
when we have a built-in one is a no.
I wouldn't agree to having it optional in this case either. Users
can explicitly request it as a filter and use it, which fits in better
with its very explicit programming model too.
_______________________________________________
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 v2 00/13] YUVJ removal

[Vittorio Giovara]

On Fri, Oct 13, 2023 at 5:14 PM Lynne <dev@lynne.ee> wrote:

> Oct 13, 2023, 20:33 by vittorio.giovara@gmail.com:
>
> > On Fri, Oct 13, 2023 at 10:27 AM Niklas Haas <ffmpeg@haasn.xyz> wrote:
> >
> >> Changes since v1:
> >>
> >> - Remove unneeded patch (AVCodecContext.colorspace init)
> >> - Merge auto-range conversion into auto-scale filter
> >> - Replace vf_zscale by vf_colorspace in fftools
> >>
> >
> > Why is this? I haven't checked what vf_colorspace supports in a hot
> second,
> > but iirc zscale can handle non linear spaces better and hdr conversion
> > If it's because it's a built in filter, do you think we could first check
> > for zscale presence and fallback to colorspace?
> >
>
> vf_colorspace != swscale
>

I am aware, thanks, not sure why's related here


> Relying on external library for basic functionality that we have
> no control over, which may break its ABI or API at any moment,
> when we have a built-in one is a no.
> I wouldn't agree to having it optional in this case either. Users
> can explicitly request it as a filter and use it, which fits in better
> with its very explicit programming model too.
>

except colorspace doesn't implement necessary features and conversions that
are present in zscale afair
if it's an automation to facilitate the life of a user it shouldn't come at
the cost of producing actual good results
-- 
Vittorio
_______________________________________________
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 v2 00/13] YUVJ removal

[Lynne]

Oct 14, 2023, 00:22 by vittorio.giovara@gmail.com:

> On Fri, Oct 13, 2023 at 5:14 PM Lynne <dev@lynne.ee> wrote:
>
>> Oct 13, 2023, 20:33 by vittorio.giovara@gmail.com:
>>
>> > On Fri, Oct 13, 2023 at 10:27 AM Niklas Haas <ffmpeg@haasn.xyz> wrote:
>> >
>> >> Changes since v1:
>> >>
>> >> - Remove unneeded patch (AVCodecContext.colorspace init)
>> >> - Merge auto-range conversion into auto-scale filter
>> >> - Replace vf_zscale by vf_colorspace in fftools
>> >>
>> >
>> > Why is this? I haven't checked what vf_colorspace supports in a hot
>> second,
>> > but iirc zscale can handle non linear spaces better and hdr conversion
>> > If it's because it's a built in filter, do you think we could first check
>> > for zscale presence and fallback to colorspace?
>> >
>>
>> vf_colorspace != swscale
>>
>
> I am aware, thanks, not sure why's related here
>
>
>> Relying on external library for basic functionality that we have
>> no control over, which may break its ABI or API at any moment,
>> when we have a built-in one is a no.
>> I wouldn't agree to having it optional in this case either. Users
>> can explicitly request it as a filter and use it, which fits in better
>> with its very explicit programming model too.
>>
>
> except colorspace doesn't implement necessary features and conversions that
> are present in zscale afair
> if it's an automation to facilitate the life of a user it shouldn't come at
> the cost of producing actual good results
>

colorspace doesn't make it impossible to introduce all that is needed.
It's a cleaner codebase that we can extend.
As for HDR, I think anything but what libplacebo does is sufficient.
_______________________________________________
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 v2 00/13] YUVJ removal

[Vittorio Giovara]

On Sat, Oct 14, 2023 at 9:11 AM Lynne <dev@lynne.ee> wrote:

> Oct 14, 2023, 00:22 by vittorio.giovara@gmail.com:
>
> > On Fri, Oct 13, 2023 at 5:14 PM Lynne <dev@lynne.ee> wrote:
> >
> >> Oct 13, 2023, 20:33 by vittorio.giovara@gmail.com:
> >>
> >> > On Fri, Oct 13, 2023 at 10:27 AM Niklas Haas <ffmpeg@haasn.xyz>
> wrote:
> >> >
> >> >> Changes since v1:
> >> >>
> >> >> - Remove unneeded patch (AVCodecContext.colorspace init)
> >> >> - Merge auto-range conversion into auto-scale filter
> >> >> - Replace vf_zscale by vf_colorspace in fftools
> >> >>
> >> >
> >> > Why is this? I haven't checked what vf_colorspace supports in a hot
> >> second,
> >> > but iirc zscale can handle non linear spaces better and hdr conversion
> >> > If it's because it's a built in filter, do you think we could first
> check
> >> > for zscale presence and fallback to colorspace?
> >> >
> >>
> >> vf_colorspace != swscale
> >>
> >
> > I am aware, thanks, not sure why's related here
> >
> >
> >> Relying on external library for basic functionality that we have
> >> no control over, which may break its ABI or API at any moment,
> >> when we have a built-in one is a no.
> >> I wouldn't agree to having it optional in this case either. Users
> >> can explicitly request it as a filter and use it, which fits in better
> >> with its very explicit programming model too.
> >>
> >
> > except colorspace doesn't implement necessary features and conversions
> that
> > are present in zscale afair
> > if it's an automation to facilitate the life of a user it shouldn't come
> at
> > the cost of producing actual good results
> >
>
> colorspace doesn't make it impossible to introduce all that is needed.
> It's a cleaner codebase that we can extend.
>

* that only works on a subset of colorspaces.
Last time I checked, it would have required a massive lift to support
anything with constant luminance or the icpct formats.

As for HDR, I think anything but what libplacebo does is sufficient.
>

Right but it's also important to avoid reinventing the wheel. We could find
better solutions like having a library with different backends and bundle
them as needed.
-- 
Vittorio
_______________________________________________
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 v2 00/13] YUVJ removal

[Lynne]

Oct 14, 2023, 17:16 by vittorio.giovara@gmail.com:

> On Sat, Oct 14, 2023 at 9:11 AM Lynne <dev@lynne.ee> wrote:
>
>> Oct 14, 2023, 00:22 by vittorio.giovara@gmail.com:
>>
>> > On Fri, Oct 13, 2023 at 5:14 PM Lynne <dev@lynne.ee> wrote:
>> >
>> >> Oct 13, 2023, 20:33 by vittorio.giovara@gmail.com:
>> >>
>> >> > On Fri, Oct 13, 2023 at 10:27 AM Niklas Haas <ffmpeg@haasn.xyz>
>> wrote:
>> >> >
>> >> >> Changes since v1:
>> >> >>
>> >> >> - Remove unneeded patch (AVCodecContext.colorspace init)
>> >> >> - Merge auto-range conversion into auto-scale filter
>> >> >> - Replace vf_zscale by vf_colorspace in fftools
>> >> >>
>> >> >
>> >> > Why is this? I haven't checked what vf_colorspace supports in a hot
>> >> second,
>> >> > but iirc zscale can handle non linear spaces better and hdr conversion
>> >> > If it's because it's a built in filter, do you think we could first
>> check
>> >> > for zscale presence and fallback to colorspace?
>> >> >
>> >>
>> >> vf_colorspace != swscale
>> >>
>> >
>> > I am aware, thanks, not sure why's related here
>> >
>> >
>> >> Relying on external library for basic functionality that we have
>> >> no control over, which may break its ABI or API at any moment,
>> >> when we have a built-in one is a no.
>> >> I wouldn't agree to having it optional in this case either. Users
>> >> can explicitly request it as a filter and use it, which fits in better
>> >> with its very explicit programming model too.
>> >>
>> >
>> > except colorspace doesn't implement necessary features and conversions
>> that
>> > are present in zscale afair
>> > if it's an automation to facilitate the life of a user it shouldn't come
>> at
>> > the cost of producing actual good results
>> >
>>
>> colorspace doesn't make it impossible to introduce all that is needed.
>> It's a cleaner codebase that we can extend.
>>
>
> * that only works on a subset of colorspaces.
> Last time I checked, it would have required a massive lift to support
> anything with constant luminance or the icpct formats.
>
> As for HDR, I think anything but what libplacebo does is sufficient.
>
>>
>>
>
> Right but it's also important to avoid reinventing the wheel. We could find
> better solutions like having a library with different backends and bundle
> them as needed.
>

But we also need determinism. Tests have to pass, and bitexactness
is often required by users.
_______________________________________________
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 v2 00/13] YUVJ removal

[Ronald S. Bultje]

Hi,

On Sat, Oct 14, 2023 at 11:16 AM Vittorio Giovara <
vittorio.giovara@gmail.com> wrote:

> On Sat, Oct 14, 2023 at 9:11 AM Lynne <dev@lynne.ee> wrote:
> > colorspace doesn't make it impossible to introduce all that is needed.
> > It's a cleaner codebase that we can extend.
>
> * that only works on a subset of colorspaces.
> Last time I checked, it would have required a massive lift to support
> anything with constant luminance or the icpct formats.
>

Not at all related to the patchset anymore... But I'm curious what's
missing here, could you elaborate? It would be nice to have that documented
somewhere.

Ronald
_______________________________________________
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 v2 00/13] YUVJ removal

[Vittorio Giovara]

On Fri, Oct 20, 2023 at 8:14 AM Ronald S. Bultje <rsbultje@gmail.com> wrote:

> Hi,
>
> On Sat, Oct 14, 2023 at 11:16 AM Vittorio Giovara <
> vittorio.giovara@gmail.com> wrote:
>
> > On Sat, Oct 14, 2023 at 9:11 AM Lynne <dev@lynne.ee> wrote:
> > > colorspace doesn't make it impossible to introduce all that is needed.
> > > It's a cleaner codebase that we can extend.
> >
> > * that only works on a subset of colorspaces.
> > Last time I checked, it would have required a massive lift to support
> > anything with constant luminance or the icpct formats.
> >
>
> Not at all related to the patchset anymore... But I'm curious what's
> missing here, could you elaborate? It would be nice to have that documented
> somewhere.
>

basically the constant luminance colorspaces (bt2020c), the various ICtCp
variants, and all the HDR transfers like hlg or pq (which, to my
understanding, cannot be easily added to the filter due to how the gamma
function is built)

tbh while it's great that this functionality exists *somewhere* in ffmpeg,
this is really something that should belong to the scaler filter (whichever
implementation)
-- 
Vittorio
_______________________________________________
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 v2 00/13] YUVJ removal

[Ronald S. Bultje]

Hi,

On Fri, Oct 20, 2023 at 12:14 PM Vittorio Giovara <
vittorio.giovara@gmail.com> wrote:

> tbh while it's great that this functionality exists *somewhere* in ffmpeg,
> this is really something that should belong to the scaler filter (whichever
> implementation)
>

I agree. The reason this was done separately was to be able to have it at
all. I considered doing it in sws and realized I probably wouldn't finish
it. This was a path of less resistance.

Thanks for the difficult-to-add feature list. (I may have some more
questions later on - need to do some research for understanding.)

Ronald
_______________________________________________
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 v2 00/13] YUVJ removal

[Michael Niedermayer]

[-- Attachment #1.1: Type: text/plain, Size: 1110 bytes --]

On Fri, Oct 20, 2023 at 07:13:00PM -0400, Ronald S. Bultje wrote:
> Hi,
> 
> On Fri, Oct 20, 2023 at 12:14 PM Vittorio Giovara <
> vittorio.giovara@gmail.com> wrote:
> 
> > tbh while it's great that this functionality exists *somewhere* in ffmpeg,
> > this is really something that should belong to the scaler filter (whichever
> > implementation)
> >
> 
> I agree. The reason this was done separately was to be able to have it at
> all. I considered doing it in sws and realized I probably wouldn't finish
> it. This was a path of less resistance.

sws supports cascaded_context, with that a sws can just spawn multiple
sws to implement a path.
so if a sws can do just colorspace1->colorspace2 and one can scale
colorspace2 you can quite easily make it support
colorspace1 scaling into colorspace2 for example

so anything should be quite add-able into sws that you have an
implementation for

thx

[...]

-- 
Michael     GnuPG fingerprint: 9FF2128B147EF6730BADF133611EC787040B0FAB

The educated differ from the uneducated as much as the living from the
dead. -- Aristotle 

[-- Attachment #1.2: signature.asc --]
[-- Type: application/pgp-signature, Size: 195 bytes --]

[-- Attachment #2: Type: text/plain, Size: 251 bytes --]

_______________________________________________
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 v2 00/13] YUVJ removal

[Vittorio Giovara]

On Sat, Oct 21, 2023 at 4:20 PM Michael Niedermayer <michael@niedermayer.cc>
wrote:

> On Fri, Oct 20, 2023 at 07:13:00PM -0400, Ronald S. Bultje wrote:
> > Hi,
> >
> > On Fri, Oct 20, 2023 at 12:14 PM Vittorio Giovara <
> > vittorio.giovara@gmail.com> wrote:
> >
> > > tbh while it's great that this functionality exists *somewhere* in
> ffmpeg,
> > > this is really something that should belong to the scaler filter
> (whichever
> > > implementation)
> > >
> >
> > I agree. The reason this was done separately was to be able to have it at
> > all. I considered doing it in sws and realized I probably wouldn't finish
> > it. This was a path of less resistance.
>
> sws supports cascaded_context, with that a sws can just spawn multiple
> sws to implement a path.
> so if a sws can do just colorspace1->colorspace2 and one can scale
> colorspace2 you can quite easily make it support
> colorspace1 scaling into colorspace2 for example
>
> so anything should be quite add-able into sws that you have an
> implementation for
>

Nothing is quite easily add-able to sws, or developers would have done so
instead of writing 4 different scaling libraries
-- 
Vittorio
_______________________________________________
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 v2 00/13] YUVJ removal

[Michael Niedermayer]

[-- Attachment #1.1: Type: text/plain, Size: 1735 bytes --]

On Mon, Oct 23, 2023 at 05:56:48PM -0700, Vittorio Giovara wrote:
> On Sat, Oct 21, 2023 at 4:20 PM Michael Niedermayer <michael@niedermayer.cc>
> wrote:
> 
> > On Fri, Oct 20, 2023 at 07:13:00PM -0400, Ronald S. Bultje wrote:
> > > Hi,
> > >
> > > On Fri, Oct 20, 2023 at 12:14 PM Vittorio Giovara <
> > > vittorio.giovara@gmail.com> wrote:
> > >
> > > > tbh while it's great that this functionality exists *somewhere* in
> > ffmpeg,
> > > > this is really something that should belong to the scaler filter
> > (whichever
> > > > implementation)
> > > >
> > >
> > > I agree. The reason this was done separately was to be able to have it at
> > > all. I considered doing it in sws and realized I probably wouldn't finish
> > > it. This was a path of less resistance.
> >
> > sws supports cascaded_context, with that a sws can just spawn multiple
> > sws to implement a path.
> > so if a sws can do just colorspace1->colorspace2 and one can scale
> > colorspace2 you can quite easily make it support
> > colorspace1 scaling into colorspace2 for example
> >
> > so anything should be quite add-able into sws that you have an
> > implementation for
> >
> 
> Nothing is quite easily add-able to sws,

If you have any difficulty with sws, please ask me, iam here to
help


> or developers would have done so
> instead of writing 4 different scaling libraries

People create new libraries, new platforms and new applications all the time
for a wide range of reasons other that "Nothing is quite easily add-able"

thx

[...]
-- 
Michael     GnuPG fingerprint: 9FF2128B147EF6730BADF133611EC787040B0FAB

Everything should be made as simple as possible, but not simpler.
-- Albert Einstein

[-- Attachment #1.2: signature.asc --]
[-- Type: application/pgp-signature, Size: 195 bytes --]

[-- Attachment #2: Type: text/plain, Size: 251 bytes --]

_______________________________________________
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 v2 00/13] YUVJ removal

[Niklas Haas]

On Fri, 13 Oct 2023 14:33:11 -0400 Vittorio Giovara <vittorio.giovara@gmail.com> wrote:
> On Fri, Oct 13, 2023 at 10:27 AM Niklas Haas <ffmpeg@haasn.xyz> wrote:
> 
> > Changes since v1:
> >
> > - Remove unneeded patch (AVCodecContext.colorspace init)
> > - Merge auto-range conversion into auto-scale filter
> > - Replace vf_zscale by vf_colorspace in fftools
> >
> 
> Why is this? I haven't checked what vf_colorspace supports in a hot second,
> but iirc zscale can handle non linear spaces better and hdr conversion
> If it's because it's a built in filter, do you think we could first check
> for zscale presence and fallback to colorspace?
> 
> - Add some miscellaneous fixes for various FATE tests
> > - Clean up some additional vestigiaul YUVJ remnants
> >

N.B.: Another issue with vf_scale/vf_colorspace is that vf_scale
currently doesn't handle colorspace metadata at all, which is blocking
the ability to add this (easily) to filter negotiation, since filter
negotiation hard-codes the "scale" filter for auto-converting between
any mismatch.

I am considering even just dropping the extended colorspace metadata
(primaries, trc) from this series completely, or at least splitting them
into separate patchsets. One to only remove YUVJ and add the color range
+ filter negotiation, and one to add all of the remaining colorspace
metadata.

Then the bikeshed about how to convert between these remaining bits of
metadata can be left to that series, and not block YUVJ removal.
_______________________________________________
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 v2 00/13] YUVJ removal

[Vittorio Giovara]

On Fri, Oct 20, 2023 at 7:30 AM Niklas Haas <ffmpeg@haasn.xyz> wrote:

> On Fri, 13 Oct 2023 14:33:11 -0400 Vittorio Giovara <
> vittorio.giovara@gmail.com> wrote:
> > On Fri, Oct 13, 2023 at 10:27 AM Niklas Haas <ffmpeg@haasn.xyz> wrote:
> >
> > > Changes since v1:
> > >
> > > - Remove unneeded patch (AVCodecContext.colorspace init)
> > > - Merge auto-range conversion into auto-scale filter
> > > - Replace vf_zscale by vf_colorspace in fftools
> > >
> >
> > Why is this? I haven't checked what vf_colorspace supports in a hot
> second,
> > but iirc zscale can handle non linear spaces better and hdr conversion
> > If it's because it's a built in filter, do you think we could first check
> > for zscale presence and fallback to colorspace?
> >
> > - Add some miscellaneous fixes for various FATE tests
> > > - Clean up some additional vestigiaul YUVJ remnants
> > >
>
> N.B.: Another issue with vf_scale/vf_colorspace is that vf_scale
> currently doesn't handle colorspace metadata at all, which is blocking
> the ability to add this (easily) to filter negotiation, since filter
> negotiation hard-codes the "scale" filter for auto-converting between
> any mismatch.
>

IMO having a solution that improves the status quo is welcome, so as long
as there is /a/ way in which ffmpeg can output correct colorspaces
automatically it should be added, even if this requires pulling in external
dependencies like for zscale. Like I believe that producing correct
conversion should be the priority, and once the design is good enough we
can address the presence of the functionality in the codebase or not.


> I am considering even just dropping the extended colorspace metadata
> (primaries, trc) from this series completely, or at least splitting them
> into separate patchsets. One to only remove YUVJ and add the color range
> + filter negotiation, and one to add all of the remaining colorspace
> metadata.


+1 to splitting the set a bit more, like proposed
-- 
Vittorio
_______________________________________________
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".