[FFmpeg-cvslog] avcodec/defs: Add AV_PROFILE_* defines, deprecate FF_PROFILE_* defines

Andreas Rheinhardt git at videolan.org
Thu Sep 7 02:19:17 EEST 2023


ffmpeg | branch: master | Andreas Rheinhardt <andreas.rheinhardt at outlook.com> | Sat Sep  2 14:57:41 2023 +0200| [8238bc0b5e3dba271217b1223a901b3f9713dc6e] | committer: Andreas Rheinhardt

avcodec/defs: Add AV_PROFILE_* defines, deprecate FF_PROFILE_* defines

These defines are also used in other contexts than just AVCodecContext
ones, e.g. in libavformat. Furthermore, given that these defines are
public, the AV-prefix is the right one, so deprecate (and not just move)
the FF-macros.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt at outlook.com>

> http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=8238bc0b5e3dba271217b1223a901b3f9713dc6e
---

 doc/APIchanges                       |   4 +
 fftools/ffprobe.c                    |   2 +-
 libavcodec/aacdec_template.c         |   8 +-
 libavcodec/aacenc.c                  |  14 +-
 libavcodec/aacenc_ltp.c              |   4 +-
 libavcodec/aacenc_pred.c             |   2 +-
 libavcodec/aacenc_tns.c              |   2 +-
 libavcodec/aacenctab.h               |   8 +-
 libavcodec/aacsbr_template.c         |   2 +-
 libavcodec/ac3dec.c                  |   2 +-
 libavcodec/amfenc_av1.c              |   4 +-
 libavcodec/amfenc_h264.c             |  12 +-
 libavcodec/amfenc_hevc.c             |   4 +-
 libavcodec/audiotoolboxenc.c         |  22 ++--
 libavcodec/avcodec.h                 |  10 ++
 libavcodec/cbs_av1.c                 |   2 +-
 libavcodec/cbs_av1_syntax_template.c |  12 +-
 libavcodec/codec.h                   |   2 +-
 libavcodec/codec_desc.h              |   2 +-
 libavcodec/codec_par.c               |   4 +-
 libavcodec/dca_core.c                |   8 +-
 libavcodec/dca_lbr.c                 |   2 +-
 libavcodec/dca_parser.c              |  16 +--
 libavcodec/dca_xll.c                 |   6 +-
 libavcodec/defs.h                    | 135 ++++++++++++++++++++
 libavcodec/dnxhddata.c               |  14 +-
 libavcodec/dnxhddec.c                |  14 +-
 libavcodec/dnxhdenc.c                |  36 +++---
 libavcodec/dxva2.c                   |  38 +++---
 libavcodec/h264_parse.c              |  14 +-
 libavcodec/hevc_ps.c                 |  12 +-
 libavcodec/hevcdec.c                 |   2 +-
 libavcodec/jpeg2000dec.c             |   4 +-
 libavcodec/libaomdec.c               |  18 +--
 libavcodec/libaomenc.c               |  14 +-
 libavcodec/libaribb24.c              |  24 ++--
 libavcodec/libaribcaption.c          |  12 +-
 libavcodec/libfdk-aacenc.c           |  28 ++--
 libavcodec/libopenh264enc.c          |  38 +++---
 libavcodec/libsvtav1.c               |  12 +-
 libavcodec/libvpxdec.c               |  16 +--
 libavcodec/libvpxenc.c               |   2 +-
 libavcodec/libx264.c                 |  12 +-
 libavcodec/mediacodec_wrapper.c      |  76 +++++------
 libavcodec/mediacodecenc.c           |  28 ++--
 libavcodec/mfenc.c                   |   4 +-
 libavcodec/mjpegdec.c                |  10 +-
 libavcodec/mlpdec.c                  |   2 +-
 libavcodec/mpeg12enc.c               |  16 +--
 libavcodec/mpeg4videodec.c           |   6 +-
 libavcodec/mpeg4videoenc.c           |   4 +-
 libavcodec/nvenc.c                   |  24 ++--
 libavcodec/nvenc_hevc.c              |   2 +-
 libavcodec/omx.c                     |  16 +--
 libavcodec/options_table.h           |   6 +-
 libavcodec/profiles.c                | 240 +++++++++++++++++------------------
 libavcodec/profiles.h                |  46 +++----
 libavcodec/proresdec2.c              |  14 +-
 libavcodec/proresenc_anatoliy.c      |  36 +++---
 libavcodec/sbcenc.c                  |   4 +-
 libavcodec/utils.c                   |   8 +-
 libavcodec/v4l2_m2m_enc.c            |  36 +++---
 libavcodec/vaapi_decode.c            |   4 +-
 libavcodec/vaapi_encode.c            |   4 +-
 libavcodec/vaapi_encode.h            |   4 +-
 libavcodec/vaapi_encode_h264.c       |  72 +++++------
 libavcodec/vaapi_encode_h265.c       |  42 +++---
 libavcodec/vaapi_encode_mjpeg.c      |  10 +-
 libavcodec/vaapi_encode_mpeg2.c      |  16 +--
 libavcodec/vaapi_encode_vp8.c        |   2 +-
 libavcodec/vaapi_encode_vp9.c        |  10 +-
 libavcodec/vaapi_hevc.c              |  18 +--
 libavcodec/vdpau_av1.c               |   6 +-
 libavcodec/vdpau_h264.c              |  22 ++--
 libavcodec/vdpau_hevc.c              |   8 +-
 libavcodec/vdpau_mpeg12.c            |   4 +-
 libavcodec/vdpau_mpeg4.c             |   6 +-
 libavcodec/vdpau_vc1.c               |   6 +-
 libavcodec/vdpau_vp9.c               |   8 +-
 libavcodec/version.h                 |   4 +-
 libavcodec/version_major.h           |   1 +
 libavcodec/videotoolboxenc.c         |  78 ++++++------
 libavcodec/vulkan_decode.c           |   8 +-
 libavformat/av1.c                    |  10 +-
 libavformat/hlsenc.c                 |  14 +-
 libavformat/matroskadec.c            |   8 +-
 libavformat/matroskaenc.c            |   6 +-
 libavformat/movenc.c                 |   8 +-
 libavformat/mpegts.c                 |   9 +-
 libavformat/mpegtsenc.c              |   8 +-
 libavformat/mxfdec.c                 |   5 +-
 libavformat/mxfenc.c                 |  14 +-
 libavformat/vpcc.c                   |  14 +-
 93 files changed, 879 insertions(+), 727 deletions(-)

diff --git a/doc/APIchanges b/doc/APIchanges
index ff0e543403..762c2d6628 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-09-07 - xxxxxxxxxx - lavc 60.26.100 - defs.h
+  Add AV_PROFILE_* and AV_LEVEL_* replacements in defs.h for the
+  defines from avcodec.h. The latter are deprecated.
+
 2023-09-06 - xxxxxxxxxx - lavc 60.25.101 - avcodec.h
   AVCodecContext.rc_buffer_size may now be set by decoders.
 
diff --git a/fftools/ffprobe.c b/fftools/ffprobe.c
index 4fcfe1164b..c20f464623 100644
--- a/fftools/ffprobe.c
+++ b/fftools/ffprobe.c
@@ -3020,7 +3020,7 @@ static int show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_id
     if (!do_bitexact && (profile = avcodec_profile_name(par->codec_id, par->profile)))
         print_str("profile", profile);
     else {
-        if (par->profile != FF_PROFILE_UNKNOWN) {
+        if (par->profile != AV_PROFILE_UNKNOWN) {
             char profile_num[12];
             snprintf(profile_num, sizeof(profile_num), "%d", par->profile);
             print_str("profile", profile_num);
diff --git a/libavcodec/aacdec_template.c b/libavcodec/aacdec_template.c
index e8dcd460a0..f8039e490b 100644
--- a/libavcodec/aacdec_template.c
+++ b/libavcodec/aacdec_template.c
@@ -2486,12 +2486,12 @@ static int decode_extension_payload(AACContext *ac, GetBitContext *gb, int cnt,
                    ac->avctx->ch_layout.nb_channels == 1) {
             ac->oc[1].m4ac.sbr = 1;
             ac->oc[1].m4ac.ps = 1;
-            ac->avctx->profile = FF_PROFILE_AAC_HE_V2;
+            ac->avctx->profile = AV_PROFILE_AAC_HE_V2;
             output_configure(ac, ac->oc[1].layout_map, ac->oc[1].layout_map_tags,
                              ac->oc[1].status, 1);
         } else {
             ac->oc[1].m4ac.sbr = 1;
-            ac->avctx->profile = FF_PROFILE_AAC_HE;
+            ac->avctx->profile = AV_PROFILE_AAC_HE;
         }
         res = AAC_RENAME(ff_decode_sbr_extension)(ac, &che->sbr, gb, crc_flag, cnt, elem_type);
         if (ac->oc[1].m4ac.ps == 1 && !ac->warned_he_aac_mono) {
@@ -3080,7 +3080,7 @@ static int aac_decode_er_frame(AVCodecContext *avctx, void *data,
     if ((err = frame_configure_elements(avctx)) < 0)
         return err;
 
-    // The FF_PROFILE_AAC_* defines are all object_type - 1
+    // The AV_PROFILE_AAC_* defines are all object_type - 1
     // This may lead to an undefined profile being signaled
     ac->avctx->profile = aot - 1;
 
@@ -3163,7 +3163,7 @@ static int aac_decode_frame_int(AVCodecContext *avctx, AVFrame *frame,
     if ((err = frame_configure_elements(avctx)) < 0)
         goto fail;
 
-    // The FF_PROFILE_AAC_* defines are all object_type - 1
+    // The AV_PROFILE_AAC_* defines are all object_type - 1
     // This may lead to an undefined profile being signaled
     ac->avctx->profile = ac->oc[1].m4ac.object_type - 1;
 
diff --git a/libavcodec/aacenc.c b/libavcodec/aacenc.c
index f48f057022..2a34685aec 100644
--- a/libavcodec/aacenc.c
+++ b/libavcodec/aacenc.c
@@ -1307,13 +1307,13 @@ static av_cold int aac_encode_init(AVCodecContext *avctx)
                                      avctx->bit_rate);
 
     /* Profile and option setting */
-    avctx->profile = avctx->profile == FF_PROFILE_UNKNOWN ? FF_PROFILE_AAC_LOW :
+    avctx->profile = avctx->profile == AV_PROFILE_UNKNOWN ? AV_PROFILE_AAC_LOW :
                      avctx->profile;
     for (i = 0; i < FF_ARRAY_ELEMS(aacenc_profiles); i++)
         if (avctx->profile == aacenc_profiles[i])
             break;
-    if (avctx->profile == FF_PROFILE_MPEG2_AAC_LOW) {
-        avctx->profile = FF_PROFILE_AAC_LOW;
+    if (avctx->profile == AV_PROFILE_MPEG2_AAC_LOW) {
+        avctx->profile = AV_PROFILE_AAC_LOW;
         ERROR_IF(s->options.pred,
                  "Main prediction unavailable in the \"mpeg2_aac_low\" profile\n");
         ERROR_IF(s->options.ltp,
@@ -1321,22 +1321,22 @@ static av_cold int aac_encode_init(AVCodecContext *avctx)
         WARN_IF(s->options.pns,
                 "PNS unavailable in the \"mpeg2_aac_low\" profile, turning off\n");
         s->options.pns = 0;
-    } else if (avctx->profile == FF_PROFILE_AAC_LTP) {
+    } else if (avctx->profile == AV_PROFILE_AAC_LTP) {
         s->options.ltp = 1;
         ERROR_IF(s->options.pred,
                  "Main prediction unavailable in the \"aac_ltp\" profile\n");
-    } else if (avctx->profile == FF_PROFILE_AAC_MAIN) {
+    } else if (avctx->profile == AV_PROFILE_AAC_MAIN) {
         s->options.pred = 1;
         ERROR_IF(s->options.ltp,
                  "LTP prediction unavailable in the \"aac_main\" profile\n");
     } else if (s->options.ltp) {
-        avctx->profile = FF_PROFILE_AAC_LTP;
+        avctx->profile = AV_PROFILE_AAC_LTP;
         WARN_IF(1,
                 "Chainging profile to \"aac_ltp\"\n");
         ERROR_IF(s->options.pred,
                  "Main prediction unavailable in the \"aac_ltp\" profile\n");
     } else if (s->options.pred) {
-        avctx->profile = FF_PROFILE_AAC_MAIN;
+        avctx->profile = AV_PROFILE_AAC_MAIN;
         WARN_IF(1,
                 "Chainging profile to \"aac_main\"\n");
         ERROR_IF(s->options.ltp,
diff --git a/libavcodec/aacenc_ltp.c b/libavcodec/aacenc_ltp.c
index f7fb85bbf8..f3075f0e71 100644
--- a/libavcodec/aacenc_ltp.c
+++ b/libavcodec/aacenc_ltp.c
@@ -37,7 +37,7 @@ void ff_aac_encode_ltp_info(AACEncContext *s, SingleChannelElement *sce,
 {
     int i;
     IndividualChannelStream *ics = &sce->ics;
-    if (s->profile != FF_PROFILE_AAC_LTP || !ics->predictor_present)
+    if (s->profile != AV_PROFILE_AAC_LTP || !ics->predictor_present)
         return;
     if (common_window)
         put_bits(&s->pb, 1, 0);
@@ -119,7 +119,7 @@ void ff_aac_update_ltp(AACEncContext *s, SingleChannelElement *sce)
     float *pred_signal = &sce->ltp_state[0];
     const float *samples = &s->planar_samples[s->cur_channel][1024];
 
-    if (s->profile != FF_PROFILE_AAC_LTP)
+    if (s->profile != AV_PROFILE_AAC_LTP)
         return;
 
     /* Calculate lag */
diff --git a/libavcodec/aacenc_pred.c b/libavcodec/aacenc_pred.c
index 447444cb82..f87fcd5a00 100644
--- a/libavcodec/aacenc_pred.c
+++ b/libavcodec/aacenc_pred.c
@@ -335,7 +335,7 @@ void ff_aac_encode_main_pred(AACEncContext *s, SingleChannelElement *sce)
     IndividualChannelStream *ics = &sce->ics;
     const int pmax = FFMIN(ics->max_sfb, ff_aac_pred_sfb_max[s->samplerate_index]);
 
-    if (s->profile != FF_PROFILE_AAC_MAIN ||
+    if (s->profile != AV_PROFILE_AAC_MAIN ||
         !ics->predictor_present)
         return;
 
diff --git a/libavcodec/aacenc_tns.c b/libavcodec/aacenc_tns.c
index 195ff5e2b7..8dc6dfcf62 100644
--- a/libavcodec/aacenc_tns.c
+++ b/libavcodec/aacenc_tns.c
@@ -167,7 +167,7 @@ void ff_aac_search_for_tns(AACEncContext *s, SingleChannelElement *sce)
     const int c_bits = is8 ? TNS_Q_BITS_IS8 == 4 : TNS_Q_BITS == 4;
     const int sfb_start = av_clip(tns_min_sfb[is8][s->samplerate_index], 0, mmm);
     const int sfb_end   = av_clip(sce->ics.num_swb, 0, mmm);
-    const int order = is8 ? 7 : s->profile == FF_PROFILE_AAC_LOW ? 12 : TNS_MAX_ORDER;
+    const int order = is8 ? 7 : s->profile == AV_PROFILE_AAC_LOW ? 12 : TNS_MAX_ORDER;
     const int slant = sce->ics.window_sequence[0] == LONG_STOP_SEQUENCE  ? 1 :
                       sce->ics.window_sequence[0] == LONG_START_SEQUENCE ? 0 : 2;
     const int sfb_len = sfb_end - sfb_start;
diff --git a/libavcodec/aacenctab.h b/libavcodec/aacenctab.h
index 2d96621945..20e47ea900 100644
--- a/libavcodec/aacenctab.h
+++ b/libavcodec/aacenctab.h
@@ -124,10 +124,10 @@ static const unsigned char aac_maxval_cb[] = {
 };
 
 static const int aacenc_profiles[] = {
-    FF_PROFILE_AAC_MAIN,
-    FF_PROFILE_AAC_LOW,
-    FF_PROFILE_AAC_LTP,
-    FF_PROFILE_MPEG2_AAC_LOW,
+    AV_PROFILE_AAC_MAIN,
+    AV_PROFILE_AAC_LOW,
+    AV_PROFILE_AAC_LTP,
+    AV_PROFILE_MPEG2_AAC_LOW,
 };
 
 #endif /* AVCODEC_AACENCTAB_H */
diff --git a/libavcodec/aacsbr_template.c b/libavcodec/aacsbr_template.c
index cdca402f04..b33ffd4295 100644
--- a/libavcodec/aacsbr_template.c
+++ b/libavcodec/aacsbr_template.c
@@ -973,7 +973,7 @@ static void read_sbr_extension(AACContext *ac, SpectralBandReplication *sbr,
             *num_bits_left = 0;
         } else {
             *num_bits_left -= ff_ps_read_data(ac->avctx, gb, &sbr->ps.common, *num_bits_left);
-            ac->avctx->profile = FF_PROFILE_AAC_HE_V2;
+            ac->avctx->profile = AV_PROFILE_AAC_HE_V2;
             // ensure the warning is not printed if PS extension is present
             ac->warned_he_aac_mono = 1;
         }
diff --git a/libavcodec/ac3dec.c b/libavcodec/ac3dec.c
index 8c63f015f4..ee50138605 100644
--- a/libavcodec/ac3dec.c
+++ b/libavcodec/ac3dec.c
@@ -1714,7 +1714,7 @@ skip:
     if (!err) {
         avctx->sample_rate = s->sample_rate;
         avctx->bit_rate    = s->bit_rate + s->prev_bit_rate;
-        avctx->profile     = s->eac3_extension_type_a == 1 ? FF_PROFILE_EAC3_DDP_ATMOS : FF_PROFILE_UNKNOWN;
+        avctx->profile     = s->eac3_extension_type_a == 1 ? AV_PROFILE_EAC3_DDP_ATMOS : AV_PROFILE_UNKNOWN;
     }
 
     if (!avctx->sample_rate) {
diff --git a/libavcodec/amfenc_av1.c b/libavcodec/amfenc_av1.c
index 30c0a9fad2..8f13aea29e 100644
--- a/libavcodec/amfenc_av1.c
+++ b/libavcodec/amfenc_av1.c
@@ -192,7 +192,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
     AMF_ASSIGN_PROPERTY_RATE(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_FRAMERATE, framerate);
 
     switch (avctx->profile) {
-    case FF_PROFILE_AV1_MAIN:
+    case AV_PROFILE_AV1_MAIN:
         profile = AMF_VIDEO_ENCODER_AV1_PROFILE_MAIN;
         break;
     default:
@@ -204,7 +204,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
     AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_AV1_PROFILE, profile);
 
     profile_level = avctx->level;
-    if (profile_level == FF_LEVEL_UNKNOWN) {
+    if (profile_level == AV_LEVEL_UNKNOWN) {
         profile_level = ctx->level;
     }
     if (profile_level != 0) {
diff --git a/libavcodec/amfenc_h264.c b/libavcodec/amfenc_h264.c
index 2380aa4e90..bd544d12df 100644
--- a/libavcodec/amfenc_h264.c
+++ b/libavcodec/amfenc_h264.c
@@ -223,19 +223,19 @@ FF_ENABLE_DEPRECATION_WARNINGS
     AMF_ASSIGN_PROPERTY_RATE(res, ctx->encoder, AMF_VIDEO_ENCODER_FRAMERATE, framerate);
 
     switch (avctx->profile) {
-    case FF_PROFILE_H264_BASELINE:
+    case AV_PROFILE_H264_BASELINE:
         profile = AMF_VIDEO_ENCODER_PROFILE_BASELINE;
         break;
-    case FF_PROFILE_H264_MAIN:
+    case AV_PROFILE_H264_MAIN:
         profile = AMF_VIDEO_ENCODER_PROFILE_MAIN;
         break;
-    case FF_PROFILE_H264_HIGH:
+    case AV_PROFILE_H264_HIGH:
         profile = AMF_VIDEO_ENCODER_PROFILE_HIGH;
         break;
-    case FF_PROFILE_H264_CONSTRAINED_BASELINE:
+    case AV_PROFILE_H264_CONSTRAINED_BASELINE:
         profile = AMF_VIDEO_ENCODER_PROFILE_CONSTRAINED_BASELINE;
         break;
-    case (FF_PROFILE_H264_HIGH | FF_PROFILE_H264_CONSTRAINED):
+    case (AV_PROFILE_H264_HIGH | AV_PROFILE_H264_CONSTRAINED):
         profile = AMF_VIDEO_ENCODER_PROFILE_CONSTRAINED_HIGH;
         break;
     }
@@ -246,7 +246,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
     AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_PROFILE, profile);
 
     profile_level = avctx->level;
-    if (profile_level == FF_LEVEL_UNKNOWN) {
+    if (profile_level == AV_LEVEL_UNKNOWN) {
         profile_level = ctx->level;
     }
     if (profile_level != 0) {
diff --git a/libavcodec/amfenc_hevc.c b/libavcodec/amfenc_hevc.c
index dd232cc8ac..352564a301 100644
--- a/libavcodec/amfenc_hevc.c
+++ b/libavcodec/amfenc_hevc.c
@@ -184,7 +184,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
     AMF_ASSIGN_PROPERTY_RATE(res, ctx->encoder, AMF_VIDEO_ENCODER_HEVC_FRAMERATE, framerate);
 
     switch (avctx->profile) {
-    case FF_PROFILE_HEVC_MAIN:
+    case AV_PROFILE_HEVC_MAIN:
         profile = AMF_VIDEO_ENCODER_HEVC_PROFILE_MAIN;
         break;
     default:
@@ -198,7 +198,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
     AMF_ASSIGN_PROPERTY_INT64(res, ctx->encoder, AMF_VIDEO_ENCODER_HEVC_TIER, ctx->tier);
 
     profile_level = avctx->level;
-    if (profile_level == FF_LEVEL_UNKNOWN) {
+    if (profile_level == AV_LEVEL_UNKNOWN) {
         profile_level = ctx->level;
     }
     if (profile_level != 0) {
diff --git a/libavcodec/audiotoolboxenc.c b/libavcodec/audiotoolboxenc.c
index 46aca4c7ff..1b4e2a6c43 100644
--- a/libavcodec/audiotoolboxenc.c
+++ b/libavcodec/audiotoolboxenc.c
@@ -60,17 +60,17 @@ static UInt32 ffat_get_format_id(enum AVCodecID codec, int profile)
     switch (codec) {
     case AV_CODEC_ID_AAC:
         switch (profile) {
-        case FF_PROFILE_AAC_LOW:
+        case AV_PROFILE_AAC_LOW:
         default:
             return kAudioFormatMPEG4AAC;
-        case FF_PROFILE_AAC_HE:
+        case AV_PROFILE_AAC_HE:
             return kAudioFormatMPEG4AAC_HE;
-        case FF_PROFILE_AAC_HE_V2:
+        case AV_PROFILE_AAC_HE_V2:
             return kAudioFormatMPEG4AAC_HE_V2;
-        case FF_PROFILE_AAC_LD:
+        case AV_PROFILE_AAC_LD:
             return kAudioFormatMPEG4AAC_LD;
 #if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060
-        case FF_PROFILE_AAC_ELD:
+        case AV_PROFILE_AAC_ELD:
             return kAudioFormatMPEG4AAC_ELD;
 #endif
         }
@@ -586,12 +586,12 @@ static av_cold int ffat_close_encoder(AVCodecContext *avctx)
 }
 
 static const AVProfile aac_profiles[] = {
-    { FF_PROFILE_AAC_LOW,   "LC"       },
-    { FF_PROFILE_AAC_HE,    "HE-AAC"   },
-    { FF_PROFILE_AAC_HE_V2, "HE-AACv2" },
-    { FF_PROFILE_AAC_LD,    "LD"       },
-    { FF_PROFILE_AAC_ELD,   "ELD"      },
-    { FF_PROFILE_UNKNOWN },
+    { AV_PROFILE_AAC_LOW,   "LC"       },
+    { AV_PROFILE_AAC_HE,    "HE-AAC"   },
+    { AV_PROFILE_AAC_HE_V2, "HE-AACv2" },
+    { AV_PROFILE_AAC_LD,    "LD"       },
+    { AV_PROFILE_AAC_ELD,   "ELD"      },
+    { AV_PROFILE_UNKNOWN },
 };
 
 #define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
diff --git a/libavcodec/avcodec.h b/libavcodec/avcodec.h
index 1f477209b0..da3c5234a0 100644
--- a/libavcodec/avcodec.h
+++ b/libavcodec/avcodec.h
@@ -1587,8 +1587,12 @@ typedef struct AVCodecContext {
      * profile
      * - encoding: Set by user.
      * - decoding: Set by libavcodec.
+     * See the AV_PROFILE_* defines in defs.h.
      */
      int profile;
+#if FF_API_FF_PROFILE_LEVEL
+    /** @deprecated The following defines are deprecated; use AV_PROFILE_*
+     * in defs.h instead. */
 #define FF_PROFILE_UNKNOWN -99
 #define FF_PROFILE_RESERVED -100
 
@@ -1719,14 +1723,20 @@ typedef struct AVCodecContext {
 
 #define FF_PROFILE_EVC_BASELINE             0
 #define FF_PROFILE_EVC_MAIN                 1
+#endif
 
     /**
      * level
      * - encoding: Set by user.
      * - decoding: Set by libavcodec.
+     * See AV_LEVEL_* in defs.h.
      */
      int level;
+#if FF_API_FF_PROFILE_LEVEL
+    /** @deprecated The following define is deprecated; use AV_LEVEL_UNKOWN
+     * in defs.h instead. */
 #define FF_LEVEL_UNKNOWN -99
+#endif
 
     /**
      * Skip loop filtering for selected frames.
diff --git a/libavcodec/cbs_av1.c b/libavcodec/cbs_av1.c
index 452e022b36..7fb5bd8b42 100644
--- a/libavcodec/cbs_av1.c
+++ b/libavcodec/cbs_av1.c
@@ -20,10 +20,10 @@
 #include "libavutil/opt.h"
 #include "libavutil/pixfmt.h"
 
-#include "avcodec.h"
 #include "cbs.h"
 #include "cbs_internal.h"
 #include "cbs_av1.h"
+#include "defs.h"
 
 
 static int cbs_av1_read_uvlc(CodedBitstreamContext *ctx, GetBitContext *gbc,
diff --git a/libavcodec/cbs_av1_syntax_template.c b/libavcodec/cbs_av1_syntax_template.c
index a747e17784..6f09c4e410 100644
--- a/libavcodec/cbs_av1_syntax_template.c
+++ b/libavcodec/cbs_av1_syntax_template.c
@@ -82,7 +82,7 @@ static int FUNC(color_config)(CodedBitstreamContext *ctx, RWContext *rw,
 
     flag(high_bitdepth);
 
-    if (seq_profile == FF_PROFILE_AV1_PROFESSIONAL &&
+    if (seq_profile == AV_PROFILE_AV1_PROFESSIONAL &&
         current->high_bitdepth) {
         flag(twelve_bit);
         priv->bit_depth = current->twelve_bit ? 12 : 10;
@@ -90,7 +90,7 @@ static int FUNC(color_config)(CodedBitstreamContext *ctx, RWContext *rw,
         priv->bit_depth = current->high_bitdepth ? 10 : 8;
     }
 
-    if (seq_profile == FF_PROFILE_AV1_HIGH)
+    if (seq_profile == AV_PROFILE_AV1_HIGH)
         infer(mono_chrome, 0);
     else
         flag(mono_chrome);
@@ -126,10 +126,10 @@ static int FUNC(color_config)(CodedBitstreamContext *ctx, RWContext *rw,
     } else {
         flag(color_range);
 
-        if (seq_profile == FF_PROFILE_AV1_MAIN) {
+        if (seq_profile == AV_PROFILE_AV1_MAIN) {
             infer(subsampling_x, 1);
             infer(subsampling_y, 1);
-        } else if (seq_profile == FF_PROFILE_AV1_HIGH) {
+        } else if (seq_profile == AV_PROFILE_AV1_HIGH) {
             infer(subsampling_x, 0);
             infer(subsampling_y, 0);
         } else {
@@ -190,8 +190,8 @@ static int FUNC(sequence_header_obu)(CodedBitstreamContext *ctx, RWContext *rw,
 
     HEADER("Sequence Header");
 
-    fc(3, seq_profile, FF_PROFILE_AV1_MAIN,
-                       FF_PROFILE_AV1_PROFESSIONAL);
+    fc(3, seq_profile, AV_PROFILE_AV1_MAIN,
+                       AV_PROFILE_AV1_PROFESSIONAL);
     flag(still_picture);
     flag(reduced_still_picture_header);
 
diff --git a/libavcodec/codec.h b/libavcodec/codec.h
index 7a932d75dd..8034f1a53c 100644
--- a/libavcodec/codec.h
+++ b/libavcodec/codec.h
@@ -217,7 +217,7 @@ typedef struct AVCodec {
     const uint64_t *channel_layouts;         ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
 #endif
     const AVClass *priv_class;              ///< AVClass for the private context
-    const AVProfile *profiles;              ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
+    const AVProfile *profiles;              ///< array of recognized profiles, or NULL if unknown, array is terminated by {AV_PROFILE_UNKNOWN}
 
     /**
      * Group name of the codec implementation.
diff --git a/libavcodec/codec_desc.h b/libavcodec/codec_desc.h
index dd4491112b..96afd20208 100644
--- a/libavcodec/codec_desc.h
+++ b/libavcodec/codec_desc.h
@@ -60,7 +60,7 @@ typedef struct AVCodecDescriptor {
     const char *const *mime_types;
     /**
      * If non-NULL, an array of profiles recognized for this codec.
-     * Terminated with FF_PROFILE_UNKNOWN.
+     * Terminated with AV_PROFILE_UNKNOWN.
      */
     const struct AVProfile *profiles;
 } AVCodecDescriptor;
diff --git a/libavcodec/codec_par.c b/libavcodec/codec_par.c
index a38a475dc7..e4e4cd48d3 100644
--- a/libavcodec/codec_par.c
+++ b/libavcodec/codec_par.c
@@ -47,8 +47,8 @@ static void codec_parameters_reset(AVCodecParameters *par)
     par->chroma_location     = AVCHROMA_LOC_UNSPECIFIED;
     par->sample_aspect_ratio = (AVRational){ 0, 1 };
     par->framerate           = (AVRational){ 0, 1 };
-    par->profile             = FF_PROFILE_UNKNOWN;
-    par->level               = FF_LEVEL_UNKNOWN;
+    par->profile             = AV_PROFILE_UNKNOWN;
+    par->level               = AV_LEVEL_UNKNOWN;
 }
 
 AVCodecParameters *avcodec_parameters_alloc(void)
diff --git a/libavcodec/dca_core.c b/libavcodec/dca_core.c
index ff3cc2fe45..60508fabb9 100644
--- a/libavcodec/dca_core.c
+++ b/libavcodec/dca_core.c
@@ -2387,13 +2387,13 @@ int ff_dca_core_filter_frame(DCACoreDecoder *s, AVFrame *frame)
 
     // Set profile, bit rate, etc
     if (s->ext_audio_mask & DCA_EXSS_MASK)
-        avctx->profile = FF_PROFILE_DTS_HD_HRA;
+        avctx->profile = AV_PROFILE_DTS_HD_HRA;
     else if (s->ext_audio_mask & (DCA_CSS_XXCH | DCA_CSS_XCH))
-        avctx->profile = FF_PROFILE_DTS_ES;
+        avctx->profile = AV_PROFILE_DTS_ES;
     else if (s->ext_audio_mask & DCA_CSS_X96)
-        avctx->profile = FF_PROFILE_DTS_96_24;
+        avctx->profile = AV_PROFILE_DTS_96_24;
     else
-        avctx->profile = FF_PROFILE_DTS;
+        avctx->profile = AV_PROFILE_DTS;
 
     if (s->bit_rate > 3 && !(s->ext_audio_mask & DCA_EXSS_MASK))
         avctx->bit_rate = s->bit_rate;
diff --git a/libavcodec/dca_lbr.c b/libavcodec/dca_lbr.c
index bef0054dbe..c9c5c0f856 100644
--- a/libavcodec/dca_lbr.c
+++ b/libavcodec/dca_lbr.c
@@ -1744,7 +1744,7 @@ int ff_dca_lbr_filter_frame(DCALbrDecoder *s, AVFrame *frame)
     avctx->sample_rate = s->sample_rate;
     avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
     avctx->bits_per_raw_sample = 0;
-    avctx->profile = FF_PROFILE_DTS_EXPRESS;
+    avctx->profile = AV_PROFILE_DTS_EXPRESS;
     avctx->bit_rate = s->bit_rate_scaled;
 
     if (s->flags & LBR_FLAG_LFE_PRESENT) {
diff --git a/libavcodec/dca_parser.c b/libavcodec/dca_parser.c
index 3148397b7d..eb0ef55d46 100644
--- a/libavcodec/dca_parser.c
+++ b/libavcodec/dca_parser.c
@@ -228,7 +228,7 @@ static int dca_parse_params(DCAParseContext *pc1, const uint8_t *buf,
 
             *sample_rate = ff_dca_sampling_freqs[pc1->sr_code];
             *duration = 1024 << ff_dca_freq_ranges[pc1->sr_code];
-            *profile = FF_PROFILE_DTS_EXPRESS;
+            *profile = AV_PROFILE_DTS_EXPRESS;
             return 0;
         }
 
@@ -253,7 +253,7 @@ static int dca_parse_params(DCAParseContext *pc1, const uint8_t *buf,
 
             *sample_rate = asset->max_sample_rate;
             *duration = (1 + (*sample_rate > 96000)) << nsamples_log2;
-            *profile = FF_PROFILE_DTS_HD_MA;
+            *profile = AV_PROFILE_DTS_HD_MA;
             return 0;
         }
 
@@ -268,18 +268,18 @@ static int dca_parse_params(DCAParseContext *pc1, const uint8_t *buf,
 
     *duration = h.npcmblocks * DCA_PCMBLOCK_SAMPLES;
     *sample_rate = ff_dca_sample_rates[h.sr_code];
-    if (*profile != FF_PROFILE_UNKNOWN)
+    if (*profile != AV_PROFILE_UNKNOWN)
         return 0;
 
-    *profile = FF_PROFILE_DTS;
+    *profile = AV_PROFILE_DTS;
     if (h.ext_audio_present) {
         switch (h.ext_audio_type) {
         case DCA_EXT_AUDIO_XCH:
         case DCA_EXT_AUDIO_XXCH:
-            *profile = FF_PROFILE_DTS_ES;
+            *profile = AV_PROFILE_DTS_ES;
             break;
         case DCA_EXT_AUDIO_X96:
-            *profile = FF_PROFILE_DTS_96_24;
+            *profile = AV_PROFILE_DTS_96_24;
             break;
         }
     }
@@ -296,9 +296,9 @@ static int dca_parse_params(DCAParseContext *pc1, const uint8_t *buf,
         return 0;
 
     if (asset->extension_mask & DCA_EXSS_XLL)
-        *profile = FF_PROFILE_DTS_HD_MA;
+        *profile = AV_PROFILE_DTS_HD_MA;
     else if (asset->extension_mask & (DCA_EXSS_XBR | DCA_EXSS_XXCH | DCA_EXSS_X96))
-        *profile = FF_PROFILE_DTS_HD_HRA;
+        *profile = AV_PROFILE_DTS_HD_HRA;
 
     return 0;
 }
diff --git a/libavcodec/dca_xll.c b/libavcodec/dca_xll.c
index b8cf37a35f..15f9bd9196 100644
--- a/libavcodec/dca_xll.c
+++ b/libavcodec/dca_xll.c
@@ -1446,11 +1446,11 @@ int ff_dca_xll_filter_frame(DCAXllDecoder *s, AVFrame *frame)
     }
 
     if (s->x_imax_syncword_present) {
-        avctx->profile = FF_PROFILE_DTS_HD_MA_X_IMAX;
+        avctx->profile = AV_PROFILE_DTS_HD_MA_X_IMAX;
     } else if (s->x_syncword_present) {
-        avctx->profile = FF_PROFILE_DTS_HD_MA_X;
+        avctx->profile = AV_PROFILE_DTS_HD_MA_X;
     } else {
-        avctx->profile = FF_PROFILE_DTS_HD_MA;
+        avctx->profile = AV_PROFILE_DTS_HD_MA;
     }
 
     avctx->bits_per_raw_sample = p->storage_bit_res;
diff --git a/libavcodec/defs.h b/libavcodec/defs.h
index fbe3254db2..ceed8d5e16 100644
--- a/libavcodec/defs.h
+++ b/libavcodec/defs.h
@@ -61,6 +61,141 @@
 #define FF_COMPLIANCE_UNOFFICIAL   -1 ///< Allow unofficial extensions
 #define FF_COMPLIANCE_EXPERIMENTAL -2 ///< Allow nonstandardized experimental things.
 
+
+#define AV_PROFILE_UNKNOWN        -99
+#define AV_PROFILE_RESERVED      -100
+
+#define AV_PROFILE_AAC_MAIN         0
+#define AV_PROFILE_AAC_LOW          1
+#define AV_PROFILE_AAC_SSR          2
+#define AV_PROFILE_AAC_LTP          3
+#define AV_PROFILE_AAC_HE           4
+#define AV_PROFILE_AAC_HE_V2       28
+#define AV_PROFILE_AAC_LD          22
+#define AV_PROFILE_AAC_ELD         38
+#define AV_PROFILE_MPEG2_AAC_LOW  128
+#define AV_PROFILE_MPEG2_AAC_HE   131
+
+#define AV_PROFILE_DNXHD         0
+#define AV_PROFILE_DNXHR_LB      1
+#define AV_PROFILE_DNXHR_SQ      2
+#define AV_PROFILE_DNXHR_HQ      3
+#define AV_PROFILE_DNXHR_HQX     4
+#define AV_PROFILE_DNXHR_444     5
+
+#define AV_PROFILE_DTS                20
+#define AV_PROFILE_DTS_ES             30
+#define AV_PROFILE_DTS_96_24          40
+#define AV_PROFILE_DTS_HD_HRA         50
+#define AV_PROFILE_DTS_HD_MA          60
+#define AV_PROFILE_DTS_EXPRESS        70
+#define AV_PROFILE_DTS_HD_MA_X        61
+#define AV_PROFILE_DTS_HD_MA_X_IMAX   62
+
+#define AV_PROFILE_EAC3_DDP_ATMOS         30
+
+#define AV_PROFILE_TRUEHD_ATMOS           30
+
+#define AV_PROFILE_MPEG2_422           0
+#define AV_PROFILE_MPEG2_HIGH          1
+#define AV_PROFILE_MPEG2_SS            2
+#define AV_PROFILE_MPEG2_SNR_SCALABLE  3
+#define AV_PROFILE_MPEG2_MAIN          4
+#define AV_PROFILE_MPEG2_SIMPLE        5
+
+#define AV_PROFILE_H264_CONSTRAINED  (1<<9)  // 8+1; constraint_set1_flag
+#define AV_PROFILE_H264_INTRA        (1<<11) // 8+3; constraint_set3_flag
+
+#define AV_PROFILE_H264_BASELINE             66
+#define AV_PROFILE_H264_CONSTRAINED_BASELINE (66|AV_PROFILE_H264_CONSTRAINED)
+#define AV_PROFILE_H264_MAIN                 77
+#define AV_PROFILE_H264_EXTENDED             88
+#define AV_PROFILE_H264_HIGH                 100
+#define AV_PROFILE_H264_HIGH_10              110
+#define AV_PROFILE_H264_HIGH_10_INTRA        (110|AV_PROFILE_H264_INTRA)
+#define AV_PROFILE_H264_MULTIVIEW_HIGH       118
+#define AV_PROFILE_H264_HIGH_422             122
+#define AV_PROFILE_H264_HIGH_422_INTRA       (122|AV_PROFILE_H264_INTRA)
+#define AV_PROFILE_H264_STEREO_HIGH          128
+#define AV_PROFILE_H264_HIGH_444             144
+#define AV_PROFILE_H264_HIGH_444_PREDICTIVE  244
+#define AV_PROFILE_H264_HIGH_444_INTRA       (244|AV_PROFILE_H264_INTRA)
+#define AV_PROFILE_H264_CAVLC_444            44
+
+#define AV_PROFILE_VC1_SIMPLE   0
+#define AV_PROFILE_VC1_MAIN     1
+#define AV_PROFILE_VC1_COMPLEX  2
+#define AV_PROFILE_VC1_ADVANCED 3
+
+#define AV_PROFILE_MPEG4_SIMPLE                     0
+#define AV_PROFILE_MPEG4_SIMPLE_SCALABLE            1
+#define AV_PROFILE_MPEG4_CORE                       2
+#define AV_PROFILE_MPEG4_MAIN                       3
+#define AV_PROFILE_MPEG4_N_BIT                      4
+#define AV_PROFILE_MPEG4_SCALABLE_TEXTURE           5
+#define AV_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION      6
+#define AV_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE     7
+#define AV_PROFILE_MPEG4_HYBRID                     8
+#define AV_PROFILE_MPEG4_ADVANCED_REAL_TIME         9
+#define AV_PROFILE_MPEG4_CORE_SCALABLE             10
+#define AV_PROFILE_MPEG4_ADVANCED_CODING           11
+#define AV_PROFILE_MPEG4_ADVANCED_CORE             12
+#define AV_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE 13
+#define AV_PROFILE_MPEG4_SIMPLE_STUDIO             14
+#define AV_PROFILE_MPEG4_ADVANCED_SIMPLE           15
+
+#define AV_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0   1
+#define AV_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1   2
+#define AV_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION  32768
+#define AV_PROFILE_JPEG2000_DCINEMA_2K              3
+#define AV_PROFILE_JPEG2000_DCINEMA_4K              4
+
+#define AV_PROFILE_VP9_0                            0
+#define AV_PROFILE_VP9_1                            1
+#define AV_PROFILE_VP9_2                            2
+#define AV_PROFILE_VP9_3                            3
+
+#define AV_PROFILE_HEVC_MAIN                        1
+#define AV_PROFILE_HEVC_MAIN_10                     2
+#define AV_PROFILE_HEVC_MAIN_STILL_PICTURE          3
+#define AV_PROFILE_HEVC_REXT                        4
+#define AV_PROFILE_HEVC_SCC                         9
+
+#define AV_PROFILE_VVC_MAIN_10                      1
+#define AV_PROFILE_VVC_MAIN_10_444                 33
+
+#define AV_PROFILE_AV1_MAIN                         0
+#define AV_PROFILE_AV1_HIGH                         1
+#define AV_PROFILE_AV1_PROFESSIONAL                 2
+
+#define AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT            0xc0
+#define AV_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT 0xc1
+#define AV_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT         0xc2
+#define AV_PROFILE_MJPEG_HUFFMAN_LOSSLESS                0xc3
+#define AV_PROFILE_MJPEG_JPEG_LS                         0xf7
+
+#define AV_PROFILE_SBC_MSBC                         1
+
+#define AV_PROFILE_PRORES_PROXY     0
+#define AV_PROFILE_PRORES_LT        1
+#define AV_PROFILE_PRORES_STANDARD  2
+#define AV_PROFILE_PRORES_HQ        3
+#define AV_PROFILE_PRORES_4444      4
+#define AV_PROFILE_PRORES_XQ        5
+
+#define AV_PROFILE_ARIB_PROFILE_A 0
+#define AV_PROFILE_ARIB_PROFILE_C 1
+
+#define AV_PROFILE_KLVA_SYNC  0
+#define AV_PROFILE_KLVA_ASYNC 1
+
+#define AV_PROFILE_EVC_BASELINE             0
+#define AV_PROFILE_EVC_MAIN                 1
+
+
+#define AV_LEVEL_UNKNOWN                  -99
+
+
 /**
  * @ingroup lavc_decoding
  */
diff --git a/libavcodec/dnxhddata.c b/libavcodec/dnxhddata.c
index d52abe87dd..ce06d77f18 100644
--- a/libavcodec/dnxhddata.c
+++ b/libavcodec/dnxhddata.c
@@ -22,7 +22,7 @@
 #include <stddef.h>
 #include "libavutil/log.h"
 #include "libavutil/macros.h"
-#include "avcodec.h"
+#include "defs.h"
 #include "dnxhddata.h"
 
 /* The quantization tables below are in zigzag order! */
@@ -1110,15 +1110,15 @@ int ff_dnxhd_get_hr_frame_size(int cid, int w, int h)
 static int dnxhd_find_hr_cid(AVCodecContext *avctx)
 {
     switch (avctx->profile) {
-    case FF_PROFILE_DNXHR_444:
+    case AV_PROFILE_DNXHR_444:
         return 1270;
-    case FF_PROFILE_DNXHR_HQX:
+    case AV_PROFILE_DNXHR_HQX:
         return 1271;
-    case FF_PROFILE_DNXHR_HQ:
+    case AV_PROFILE_DNXHR_HQ:
         return 1272;
-    case FF_PROFILE_DNXHR_SQ:
+    case AV_PROFILE_DNXHR_SQ:
         return 1273;
-    case FF_PROFILE_DNXHR_LB:
+    case AV_PROFILE_DNXHR_LB:
         return 1274;
     }
     return 0;
@@ -1129,7 +1129,7 @@ int ff_dnxhd_find_cid(AVCodecContext *avctx, int bit_depth)
     int i, j;
     int mbs = avctx->bit_rate / 1000000;
 
-    if (avctx->profile != FF_PROFILE_DNXHD)
+    if (avctx->profile != AV_PROFILE_DNXHD)
         return dnxhd_find_hr_cid(avctx);
 
     if (!mbs)
diff --git a/libavcodec/dnxhddec.c b/libavcodec/dnxhddec.c
index 834390b93b..5c49a43c8d 100644
--- a/libavcodec/dnxhddec.c
+++ b/libavcodec/dnxhddec.c
@@ -160,17 +160,17 @@ static int dnxhd_get_profile(int cid)
 {
     switch(cid) {
     case 1270:
-        return FF_PROFILE_DNXHR_444;
+        return AV_PROFILE_DNXHR_444;
     case 1271:
-        return FF_PROFILE_DNXHR_HQX;
+        return AV_PROFILE_DNXHR_HQX;
     case 1272:
-        return FF_PROFILE_DNXHR_HQ;
+        return AV_PROFILE_DNXHR_HQ;
     case 1273:
-        return FF_PROFILE_DNXHR_SQ;
+        return AV_PROFILE_DNXHR_SQ;
     case 1274:
-        return FF_PROFILE_DNXHR_LB;
+        return AV_PROFILE_DNXHR_LB;
     }
-    return FF_PROFILE_DNXHD;
+    return AV_PROFILE_DNXHD;
 }
 
 static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame,
@@ -262,7 +262,7 @@ static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame,
         ctx->decode_dct_block = dnxhd_decode_dct_block_12;
         ctx->pix_fmt = AV_PIX_FMT_YUV422P12;
     } else if (bitdepth == 10) {
-        if (ctx->avctx->profile == FF_PROFILE_DNXHR_HQX)
+        if (ctx->avctx->profile == AV_PROFILE_DNXHR_HQX)
             ctx->decode_dct_block = dnxhd_decode_dct_block_10_444;
         else
             ctx->decode_dct_block = dnxhd_decode_dct_block_10;
diff --git a/libavcodec/dnxhdenc.c b/libavcodec/dnxhdenc.c
index a1852fa6b7..f52a2e9918 100644
--- a/libavcodec/dnxhdenc.c
+++ b/libavcodec/dnxhdenc.c
@@ -54,19 +54,19 @@ static const AVOption options[] = {
         offsetof(DNXHDEncContext, intra_quant_bias), AV_OPT_TYPE_INT,
         { .i64 = 0 }, INT_MIN, INT_MAX, VE },
     { "profile",       NULL, offsetof(DNXHDEncContext, profile), AV_OPT_TYPE_INT,
-        { .i64 = FF_PROFILE_DNXHD },
-        FF_PROFILE_DNXHD, FF_PROFILE_DNXHR_444, VE, "profile" },
-    { "dnxhd",     NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_DNXHD },
+        { .i64 = AV_PROFILE_DNXHD },
+        AV_PROFILE_DNXHD, AV_PROFILE_DNXHR_444, VE, "profile" },
+    { "dnxhd",     NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_DNXHD },
         0, 0, VE, "profile" },
-    { "dnxhr_444", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_DNXHR_444 },
+    { "dnxhr_444", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_DNXHR_444 },
         0, 0, VE, "profile" },
-    { "dnxhr_hqx", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_DNXHR_HQX },
+    { "dnxhr_hqx", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_DNXHR_HQX },
         0, 0, VE, "profile" },
-    { "dnxhr_hq",  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_DNXHR_HQ },
+    { "dnxhr_hq",  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_DNXHR_HQ },
         0, 0, VE, "profile" },
-    { "dnxhr_sq",  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_DNXHR_SQ },
+    { "dnxhr_sq",  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_DNXHR_SQ },
         0, 0, VE, "profile" },
-    { "dnxhr_lb",  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_DNXHR_LB },
+    { "dnxhr_lb",  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_DNXHR_LB },
         0, 0, VE, "profile" },
     { NULL }
 };
@@ -367,30 +367,30 @@ static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
         break;
     }
 
-    if ((ctx->profile == FF_PROFILE_DNXHR_444 && (avctx->pix_fmt != AV_PIX_FMT_YUV444P10 &&
+    if ((ctx->profile == AV_PROFILE_DNXHR_444 && (avctx->pix_fmt != AV_PIX_FMT_YUV444P10 &&
                                                   avctx->pix_fmt != AV_PIX_FMT_GBRP10)) ||
-        (ctx->profile != FF_PROFILE_DNXHR_444 && (avctx->pix_fmt == AV_PIX_FMT_YUV444P10 ||
+        (ctx->profile != AV_PROFILE_DNXHR_444 && (avctx->pix_fmt == AV_PIX_FMT_YUV444P10 ||
                                                   avctx->pix_fmt == AV_PIX_FMT_GBRP10))) {
         av_log(avctx, AV_LOG_ERROR,
                "pixel format is incompatible with DNxHD profile\n");
         return AVERROR(EINVAL);
     }
 
-    if (ctx->profile == FF_PROFILE_DNXHR_HQX && avctx->pix_fmt != AV_PIX_FMT_YUV422P10) {
+    if (ctx->profile == AV_PROFILE_DNXHR_HQX && avctx->pix_fmt != AV_PIX_FMT_YUV422P10) {
         av_log(avctx, AV_LOG_ERROR,
                "pixel format is incompatible with DNxHR HQX profile\n");
         return AVERROR(EINVAL);
     }
 
-    if ((ctx->profile == FF_PROFILE_DNXHR_LB ||
-         ctx->profile == FF_PROFILE_DNXHR_SQ ||
-         ctx->profile == FF_PROFILE_DNXHR_HQ) && avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
+    if ((ctx->profile == AV_PROFILE_DNXHR_LB ||
+         ctx->profile == AV_PROFILE_DNXHR_SQ ||
+         ctx->profile == AV_PROFILE_DNXHR_HQ) && avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
         av_log(avctx, AV_LOG_ERROR,
                "pixel format is incompatible with DNxHR LB/SQ/HQ profile\n");
         return AVERROR(EINVAL);
     }
 
-    ctx->is_444 = ctx->profile == FF_PROFILE_DNXHR_444;
+    ctx->is_444 = ctx->profile == AV_PROFILE_DNXHR_444;
     avctx->profile = ctx->profile;
     ctx->cid = ff_dnxhd_find_cid(avctx, ctx->bit_depth);
     if (!ctx->cid) {
@@ -426,13 +426,13 @@ static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
     ff_pixblockdsp_init(&ctx->m.pdsp, avctx);
     ff_dct_encode_init(&ctx->m);
 
-    if (ctx->profile != FF_PROFILE_DNXHD)
+    if (ctx->profile != AV_PROFILE_DNXHD)
         ff_videodsp_init(&ctx->m.vdsp, ctx->bit_depth);
 
     if (!ctx->m.dct_quantize)
         ctx->m.dct_quantize = ff_dct_quantize_c;
 
-    if (ctx->is_444 || ctx->profile == FF_PROFILE_DNXHR_HQX) {
+    if (ctx->is_444 || ctx->profile == AV_PROFILE_DNXHR_HQX) {
         ctx->m.dct_quantize     = dnxhd_10bit_dct_quantize_444;
         ctx->get_pixels_8x4_sym = dnxhd_10bit_get_pixels_8x4_sym;
         ctx->block_width_l2     = 4;
@@ -457,7 +457,7 @@ static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
         ctx->m.mb_height /= 2;
     }
 
-    if (ctx->interlaced && ctx->profile != FF_PROFILE_DNXHD) {
+    if (ctx->interlaced && ctx->profile != AV_PROFILE_DNXHD) {
         av_log(avctx, AV_LOG_ERROR,
                "Interlaced encoding is not supported for DNxHR profiles.\n");
         return AVERROR(EINVAL);
diff --git a/libavcodec/dxva2.c b/libavcodec/dxva2.c
index 568d686f39..d7bc587562 100644
--- a/libavcodec/dxva2.c
+++ b/libavcodec/dxva2.c
@@ -53,28 +53,28 @@ DEFINE_GUID(ff_IID_IDirectXVideoDecoderService, 0xfc51a551,0xd5e7,0x11d9,0xaf,0x
 typedef struct dxva_mode {
     const GUID     *guid;
     enum AVCodecID codec;
-    // List of supported profiles, terminated by a FF_PROFILE_UNKNOWN entry.
+    // List of supported profiles, terminated by a AV_PROFILE_UNKNOWN entry.
     // If NULL, don't check profile.
     const int      *profiles;
 } dxva_mode;
 
-static const int prof_mpeg2_main[]   = {FF_PROFILE_MPEG2_SIMPLE,
-                                        FF_PROFILE_MPEG2_MAIN,
-                                        FF_PROFILE_UNKNOWN};
-static const int prof_h264_high[]    = {FF_PROFILE_H264_CONSTRAINED_BASELINE,
-                                        FF_PROFILE_H264_MAIN,
-                                        FF_PROFILE_H264_HIGH,
-                                        FF_PROFILE_UNKNOWN};
-static const int prof_hevc_main[]    = {FF_PROFILE_HEVC_MAIN,
-                                        FF_PROFILE_UNKNOWN};
-static const int prof_hevc_main10[]  = {FF_PROFILE_HEVC_MAIN_10,
-                                        FF_PROFILE_UNKNOWN};
-static const int prof_vp9_profile0[] = {FF_PROFILE_VP9_0,
-                                        FF_PROFILE_UNKNOWN};
-static const int prof_vp9_profile2[] = {FF_PROFILE_VP9_2,
-                                        FF_PROFILE_UNKNOWN};
-static const int prof_av1_profile0[] = {FF_PROFILE_AV1_MAIN,
-                                        FF_PROFILE_UNKNOWN};
+static const int prof_mpeg2_main[]   = {AV_PROFILE_MPEG2_SIMPLE,
+                                        AV_PROFILE_MPEG2_MAIN,
+                                        AV_PROFILE_UNKNOWN};
+static const int prof_h264_high[]    = {AV_PROFILE_H264_CONSTRAINED_BASELINE,
+                                        AV_PROFILE_H264_MAIN,
+                                        AV_PROFILE_H264_HIGH,
+                                        AV_PROFILE_UNKNOWN};
+static const int prof_hevc_main[]    = {AV_PROFILE_HEVC_MAIN,
+                                        AV_PROFILE_UNKNOWN};
+static const int prof_hevc_main10[]  = {AV_PROFILE_HEVC_MAIN_10,
+                                        AV_PROFILE_UNKNOWN};
+static const int prof_vp9_profile0[] = {AV_PROFILE_VP9_0,
+                                        AV_PROFILE_UNKNOWN};
+static const int prof_vp9_profile2[] = {AV_PROFILE_VP9_2,
+                                        AV_PROFILE_UNKNOWN};
+static const int prof_av1_profile0[] = {AV_PROFILE_AV1_MAIN,
+                                        AV_PROFILE_UNKNOWN};
 
 static const dxva_mode dxva_modes[] = {
     /* MPEG-2 */
@@ -199,7 +199,7 @@ static int dxva_check_codec_compatibility(AVCodecContext *avctx, const dxva_mode
 
     if (mode->profiles && !(avctx->hwaccel_flags & AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH)) {
         int i, found = 0;
-        for (i = 0; mode->profiles[i] != FF_PROFILE_UNKNOWN; i++) {
+        for (i = 0; mode->profiles[i] != AV_PROFILE_UNKNOWN; i++) {
             if (avctx->profile == mode->profiles[i]) {
                 found = 1;
                 break;
diff --git a/libavcodec/h264_parse.c b/libavcodec/h264_parse.c
index 97ddf0e437..3378650fd5 100644
--- a/libavcodec/h264_parse.c
+++ b/libavcodec/h264_parse.c
@@ -526,22 +526,22 @@ int ff_h264_decode_extradata(const uint8_t *data, int size, H264ParamSets *ps,
  *
  * @param sps SPS
  *
- * @return profile as defined by FF_PROFILE_H264_*
+ * @return profile as defined by AV_PROFILE_H264_*
  */
 int ff_h264_get_profile(const SPS *sps)
 {
     int profile = sps->profile_idc;
 
     switch (sps->profile_idc) {
-    case FF_PROFILE_H264_BASELINE:
+    case AV_PROFILE_H264_BASELINE:
         // constraint_set1_flag set to 1
-        profile |= (sps->constraint_set_flags & 1 << 1) ? FF_PROFILE_H264_CONSTRAINED : 0;
+        profile |= (sps->constraint_set_flags & 1 << 1) ? AV_PROFILE_H264_CONSTRAINED : 0;
         break;
-    case FF_PROFILE_H264_HIGH_10:
-    case FF_PROFILE_H264_HIGH_422:
-    case FF_PROFILE_H264_HIGH_444_PREDICTIVE:
+    case AV_PROFILE_H264_HIGH_10:
+    case AV_PROFILE_H264_HIGH_422:
+    case AV_PROFILE_H264_HIGH_444_PREDICTIVE:
         // constraint_set3_flag set to 1
-        profile |= (sps->constraint_set_flags & 1 << 3) ? FF_PROFILE_H264_INTRA : 0;
+        profile |= (sps->constraint_set_flags & 1 << 3) ? AV_PROFILE_H264_INTRA : 0;
         break;
     }
 
diff --git a/libavcodec/hevc_ps.c b/libavcodec/hevc_ps.c
index 1db2d3a242..bdd623507d 100644
--- a/libavcodec/hevc_ps.c
+++ b/libavcodec/hevc_ps.c
@@ -250,15 +250,15 @@ static int decode_profile_tier_level(GetBitContext *gb, AVCodecContext *avctx,
     ptl->profile_space = get_bits(gb, 2);
     ptl->tier_flag     = get_bits1(gb);
     ptl->profile_idc   = get_bits(gb, 5);
-    if (ptl->profile_idc == FF_PROFILE_HEVC_MAIN)
+    if (ptl->profile_idc == AV_PROFILE_HEVC_MAIN)
         av_log(avctx, AV_LOG_DEBUG, "Main profile bitstream\n");
-    else if (ptl->profile_idc == FF_PROFILE_HEVC_MAIN_10)
+    else if (ptl->profile_idc == AV_PROFILE_HEVC_MAIN_10)
         av_log(avctx, AV_LOG_DEBUG, "Main 10 profile bitstream\n");
-    else if (ptl->profile_idc == FF_PROFILE_HEVC_MAIN_STILL_PICTURE)
+    else if (ptl->profile_idc == AV_PROFILE_HEVC_MAIN_STILL_PICTURE)
         av_log(avctx, AV_LOG_DEBUG, "Main Still Picture profile bitstream\n");
-    else if (ptl->profile_idc == FF_PROFILE_HEVC_REXT)
+    else if (ptl->profile_idc == AV_PROFILE_HEVC_REXT)
         av_log(avctx, AV_LOG_DEBUG, "Range Extension profile bitstream\n");
-    else if (ptl->profile_idc == FF_PROFILE_HEVC_SCC)
+    else if (ptl->profile_idc == AV_PROFILE_HEVC_SCC)
         av_log(avctx, AV_LOG_DEBUG, "Screen Content Coding Extension profile bitstream\n");
     else
         av_log(avctx, AV_LOG_WARNING, "Unknown HEVC profile: %d\n", ptl->profile_idc);
@@ -1968,7 +1968,7 @@ int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
         pps->pps_scc_extension_flag        = get_bits1(gb);
         skip_bits(gb, 4); // pps_extension_4bits
 
-        if (sps->ptl.general_ptl.profile_idc >= FF_PROFILE_HEVC_REXT && pps->pps_range_extensions_flag) {
+        if (sps->ptl.general_ptl.profile_idc >= AV_PROFILE_HEVC_REXT && pps->pps_range_extensions_flag) {
             if ((ret = pps_range_extensions(gb, avctx, pps, sps)) < 0)
                 goto err;
         }
diff --git a/libavcodec/hevcdec.c b/libavcodec/hevcdec.c
index df40c91ba6..abdf19a15e 100644
--- a/libavcodec/hevcdec.c
+++ b/libavcodec/hevcdec.c
@@ -3082,7 +3082,7 @@ static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
             if (ret < 0)
                 goto fail;
         } else {
-            if (s->avctx->profile == FF_PROFILE_HEVC_SCC) {
+            if (s->avctx->profile == AV_PROFILE_HEVC_SCC) {
                 av_log(s->avctx, AV_LOG_ERROR,
                        "SCC profile is not yet implemented in hevc native decoder.\n");
                 ret = AVERROR_PATCHWELCOME;
diff --git a/libavcodec/jpeg2000dec.c b/libavcodec/jpeg2000dec.c
index d6f2a5938e..7d1a222f71 100644
--- a/libavcodec/jpeg2000dec.c
+++ b/libavcodec/jpeg2000dec.c
@@ -312,8 +312,8 @@ static int get_siz(Jpeg2000DecoderContext *s)
     if (ret < 0)
         return ret;
 
-    if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K ||
-        s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) {
+    if (s->avctx->profile == AV_PROFILE_JPEG2000_DCINEMA_2K ||
+        s->avctx->profile == AV_PROFILE_JPEG2000_DCINEMA_4K) {
         possible_fmts = xyz_pix_fmts;
         possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts);
     } else {
diff --git a/libavcodec/libaomdec.c b/libavcodec/libaomdec.c
index 767c216aa9..695d901051 100644
--- a/libavcodec/libaomdec.c
+++ b/libavcodec/libaomdec.c
@@ -78,17 +78,17 @@ static int set_pix_fmt(AVCodecContext *avctx, struct aom_image *img)
         if (img->bit_depth == 8) {
             avctx->pix_fmt = img->monochrome ?
                              AV_PIX_FMT_GRAY8 : AV_PIX_FMT_YUV420P;
-            avctx->profile = FF_PROFILE_AV1_MAIN;
+            avctx->profile = AV_PROFILE_AV1_MAIN;
             return 0;
         } else if (img->bit_depth == 10) {
             avctx->pix_fmt = img->monochrome ?
                              AV_PIX_FMT_GRAY10 : AV_PIX_FMT_YUV420P10;
-            avctx->profile = FF_PROFILE_AV1_MAIN;
+            avctx->profile = AV_PROFILE_AV1_MAIN;
             return 0;
         } else if (img->bit_depth == 12) {
             avctx->pix_fmt = img->monochrome ?
                              AV_PIX_FMT_GRAY12 : AV_PIX_FMT_YUV420P12;
-            avctx->profile = FF_PROFILE_AV1_PROFESSIONAL;
+            avctx->profile = AV_PROFILE_AV1_PROFESSIONAL;
             return 0;
         } else {
             return AVERROR_INVALIDDATA;
@@ -97,15 +97,15 @@ static int set_pix_fmt(AVCodecContext *avctx, struct aom_image *img)
     case AOM_IMG_FMT_I42216:
         if (img->bit_depth == 8) {
             avctx->pix_fmt = AV_PIX_FMT_YUV422P;
-            avctx->profile = FF_PROFILE_AV1_PROFESSIONAL;
+            avctx->profile = AV_PROFILE_AV1_PROFESSIONAL;
             return 0;
         } else if (img->bit_depth == 10) {
             avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
-            avctx->profile = FF_PROFILE_AV1_PROFESSIONAL;
+            avctx->profile = AV_PROFILE_AV1_PROFESSIONAL;
             return 0;
         } else if (img->bit_depth == 12) {
             avctx->pix_fmt = AV_PIX_FMT_YUV422P12;
-            avctx->profile = FF_PROFILE_AV1_PROFESSIONAL;
+            avctx->profile = AV_PROFILE_AV1_PROFESSIONAL;
             return 0;
         } else {
             return AVERROR_INVALIDDATA;
@@ -115,18 +115,18 @@ static int set_pix_fmt(AVCodecContext *avctx, struct aom_image *img)
         if (img->bit_depth == 8) {
             avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ?
                              AV_PIX_FMT_GBRP : AV_PIX_FMT_YUV444P;
-            avctx->profile = FF_PROFILE_AV1_HIGH;
+            avctx->profile = AV_PROFILE_AV1_HIGH;
             return 0;
         } else if (img->bit_depth == 10) {
             avctx->pix_fmt = AV_PIX_FMT_YUV444P10;
             avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ?
                              AV_PIX_FMT_GBRP10 : AV_PIX_FMT_YUV444P10;
-            avctx->profile = FF_PROFILE_AV1_HIGH;
+            avctx->profile = AV_PROFILE_AV1_HIGH;
             return 0;
         } else if (img->bit_depth == 12) {
             avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ?
                              AV_PIX_FMT_GBRP12 : AV_PIX_FMT_YUV444P12;
-            avctx->profile = FF_PROFILE_AV1_PROFESSIONAL;
+            avctx->profile = AV_PROFILE_AV1_PROFESSIONAL;
             return 0;
         } else {
             return AVERROR_INVALIDDATA;
diff --git a/libavcodec/libaomenc.c b/libavcodec/libaomenc.c
index 53a1159b75..aa800834fe 100644
--- a/libavcodec/libaomenc.c
+++ b/libavcodec/libaomenc.c
@@ -451,16 +451,16 @@ static int set_pix_fmt(AVCodecContext *avctx, aom_codec_caps_t codec_caps,
         enccfg->monochrome = 1;
         /* Fall-through */
     case AV_PIX_FMT_YUV420P:
-        enccfg->g_profile = FF_PROFILE_AV1_MAIN;
+        enccfg->g_profile = AV_PROFILE_AV1_MAIN;
         *img_fmt = AOM_IMG_FMT_I420;
         return 0;
     case AV_PIX_FMT_YUV422P:
-        enccfg->g_profile = FF_PROFILE_AV1_PROFESSIONAL;
+        enccfg->g_profile = AV_PROFILE_AV1_PROFESSIONAL;
         *img_fmt = AOM_IMG_FMT_I422;
         return 0;
     case AV_PIX_FMT_YUV444P:
     case AV_PIX_FMT_GBRP:
-        enccfg->g_profile = FF_PROFILE_AV1_HIGH;
+        enccfg->g_profile = AV_PROFILE_AV1_HIGH;
         *img_fmt = AOM_IMG_FMT_I444;
         return 0;
     case AV_PIX_FMT_GRAY10:
@@ -471,7 +471,7 @@ static int set_pix_fmt(AVCodecContext *avctx, aom_codec_caps_t codec_caps,
     case AV_PIX_FMT_YUV420P12:
         if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
             enccfg->g_profile =
-                enccfg->g_bit_depth == 10 ? FF_PROFILE_AV1_MAIN : FF_PROFILE_AV1_PROFESSIONAL;
+                enccfg->g_bit_depth == 10 ? AV_PROFILE_AV1_MAIN : AV_PROFILE_AV1_PROFESSIONAL;
             *img_fmt = AOM_IMG_FMT_I42016;
             *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
             return 0;
@@ -480,7 +480,7 @@ static int set_pix_fmt(AVCodecContext *avctx, aom_codec_caps_t codec_caps,
     case AV_PIX_FMT_YUV422P10:
     case AV_PIX_FMT_YUV422P12:
         if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
-            enccfg->g_profile = FF_PROFILE_AV1_PROFESSIONAL;
+            enccfg->g_profile = AV_PROFILE_AV1_PROFESSIONAL;
             *img_fmt = AOM_IMG_FMT_I42216;
             *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
             return 0;
@@ -492,7 +492,7 @@ static int set_pix_fmt(AVCodecContext *avctx, aom_codec_caps_t codec_caps,
     case AV_PIX_FMT_GBRP12:
         if (codec_caps & AOM_CODEC_CAP_HIGHBITDEPTH) {
             enccfg->g_profile =
-                enccfg->g_bit_depth == 10 ? FF_PROFILE_AV1_HIGH : FF_PROFILE_AV1_PROFESSIONAL;
+                enccfg->g_bit_depth == 10 ? AV_PROFILE_AV1_HIGH : AV_PROFILE_AV1_PROFESSIONAL;
             *img_fmt = AOM_IMG_FMT_I44416;
             *flags |= AOM_CODEC_USE_HIGHBITDEPTH;
             return 0;
@@ -842,7 +842,7 @@ static av_cold int aom_init(AVCodecContext *avctx,
     /* 0-3: For non-zero values the encoder increasingly optimizes for reduced
      * complexity playback on low powered devices at the expense of encode
      * quality. */
-    if (avctx->profile != FF_PROFILE_UNKNOWN)
+    if (avctx->profile != AV_PROFILE_UNKNOWN)
         enccfg.g_profile = avctx->profile;
 
     enccfg.g_error_resilient = ctx->error_resilient;
diff --git a/libavcodec/libaribb24.c b/libavcodec/libaribb24.c
index e3e244be99..8032536b22 100644
--- a/libavcodec/libaribb24.c
+++ b/libavcodec/libaribb24.c
@@ -49,13 +49,13 @@ static unsigned int get_profile_font_size(AVCodecContext *avctx)
     Libaribb24Context *b24 = avctx->priv_data;
     int profile = avctx->profile;
 
-    if (profile == FF_PROFILE_UNKNOWN)
+    if (profile == AV_PROFILE_UNKNOWN)
         profile = b24->default_profile;
 
     switch (profile) {
-    case FF_PROFILE_ARIB_PROFILE_A:
+    case AV_PROFILE_ARIB_PROFILE_A:
         return 36;
-    case FF_PROFILE_ARIB_PROFILE_C:
+    case AV_PROFILE_ARIB_PROFILE_C:
         return 18;
     default:
         return 0;
@@ -75,15 +75,15 @@ static int libaribb24_generate_ass_header(AVCodecContext *avctx)
     unsigned int font_size = 0;
     int profile = avctx->profile;
 
-    if (profile == FF_PROFILE_UNKNOWN)
+    if (profile == AV_PROFILE_UNKNOWN)
         profile = b24->default_profile;
 
     switch (profile) {
-    case FF_PROFILE_ARIB_PROFILE_A:
+    case AV_PROFILE_ARIB_PROFILE_A:
         plane_width = 960;
         plane_height = 540;
         break;
-    case FF_PROFILE_ARIB_PROFILE_C:
+    case AV_PROFILE_ARIB_PROFILE_C:
         plane_width = 320;
         plane_height = 180;
         break;
@@ -172,14 +172,14 @@ static int libaribb24_init(AVCodecContext *avctx)
         goto init_fail;
     }
 
-    if (profile == FF_PROFILE_UNKNOWN)
+    if (profile == AV_PROFILE_UNKNOWN)
         profile = b24->default_profile;
 
     switch (profile) {
-    case FF_PROFILE_ARIB_PROFILE_A:
+    case AV_PROFILE_ARIB_PROFILE_A:
         arib_dec_init = arib_initialize_decoder_a_profile;
         break;
-    case FF_PROFILE_ARIB_PROFILE_C:
+    case AV_PROFILE_ARIB_PROFILE_C:
         arib_dec_init = arib_initialize_decoder_c_profile;
         break;
     default:
@@ -390,9 +390,9 @@ static const AVOption options[] = {
     { "aribb24-skip-ruby-text", "skip ruby text blocks during decoding",
       OFFSET(aribb24_skip_ruby), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, SD },
     { "default_profile", "default profile to use if not specified in the stream parameters",
-      OFFSET(default_profile), AV_OPT_TYPE_INT, { .i64 = FF_PROFILE_UNKNOWN }, FF_PROFILE_UNKNOWN, FF_PROFILE_ARIB_PROFILE_C, SD, "profile" },
-        {"a", "Profile A", 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_ARIB_PROFILE_A}, INT_MIN, INT_MAX, SD, "profile"},
-        {"c", "Profile C", 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_ARIB_PROFILE_C}, INT_MIN, INT_MAX, SD, "profile"},
+      OFFSET(default_profile), AV_OPT_TYPE_INT, { .i64 = AV_PROFILE_UNKNOWN }, AV_PROFILE_UNKNOWN, AV_PROFILE_ARIB_PROFILE_C, SD, "profile" },
+        {"a", "Profile A", 0, AV_OPT_TYPE_CONST, {.i64 = AV_PROFILE_ARIB_PROFILE_A}, INT_MIN, INT_MAX, SD, "profile"},
+        {"c", "Profile C", 0, AV_OPT_TYPE_CONST, {.i64 = AV_PROFILE_ARIB_PROFILE_C}, INT_MIN, INT_MAX, SD, "profile"},
     { NULL }
 };
 
diff --git a/libavcodec/libaribcaption.c b/libavcodec/libaribcaption.c
index 747ca8a2e4..8a8c8f8cfd 100644
--- a/libavcodec/libaribcaption.c
+++ b/libavcodec/libaribcaption.c
@@ -452,7 +452,7 @@ static int aribcaption_trans_bitmap_subtitle(ARIBCaptionContext *ctx)
             goto fail;
         }
 
-        if (ctx->avctx->profile == FF_PROFILE_ARIB_PROFILE_C) {
+        if (ctx->avctx->profile == AV_PROFILE_ARIB_PROFILE_C) {
             /* ARIB TR-B14 version 3.8 Fascicle 1-(2/2) Volume 3 [Section 4] */
             /* No position information is provided for profile C */
             rect->x = (ctx->frame_width - rect->w) / 2;
@@ -594,7 +594,7 @@ static int aribcaption_trans_ass_subtitle(ARIBCaptionContext *ctx)
 
     /* ARIB TR-B14 version 3.8 Fascicle 1-(2/2) Volume 3 [Section 4] */
     /* No position information is provided for profile C */
-    if (ctx->avctx->profile == FF_PROFILE_ARIB_PROFILE_C)
+    if (ctx->avctx->profile == AV_PROFILE_ARIB_PROFILE_C)
         single_rect = true;
 
     sub->format = 1; /* text */
@@ -606,7 +606,7 @@ static int aribcaption_trans_ass_subtitle(ARIBCaptionContext *ctx)
 
     av_bprint_init(&buf, ARIBC_BPRINT_SIZE_INIT, ARIBC_BPRINT_SIZE_MAX);
 
-    if (single_rect && ctx->avctx->profile != FF_PROFILE_ARIB_PROFILE_C) {
+    if (single_rect && ctx->avctx->profile != AV_PROFILE_ARIB_PROFILE_C) {
         int x, y, rx, ry;
         x = ctx->plane_width;
         y = ctx->plane_height;
@@ -660,7 +660,7 @@ static int aribcaption_trans_ass_subtitle(ARIBCaptionContext *ctx)
         for (int j = 0; j < region->char_count; j++) {
             aribcc_caption_char_t *ch = &region->chars[j];
 
-            if (ctx->avctx->profile != FF_PROFILE_ARIB_PROFILE_C) {
+            if (ctx->avctx->profile != AV_PROFILE_ARIB_PROFILE_C) {
                 if (ch->char_horizontal_spacing != char_horizontal_spacing) {
                     av_bprintf(&buf, "{\\fsp%d}", (region->is_ruby) ?
                                      ch->char_horizontal_spacing / 2 :
@@ -960,14 +960,14 @@ static int aribcaption_init(AVCodecContext *avctx)
     ctx->avctx = avctx;
 
     switch (avctx->profile) {
-    case FF_PROFILE_ARIB_PROFILE_A:
+    case AV_PROFILE_ARIB_PROFILE_A:
         profile = ARIBCC_PROFILE_A;
         /* assume 960x540 at initial state */
         ctx->plane_width = 960;
         ctx->plane_height = 540;
         ctx->font_size = 36;
         break;
-    case FF_PROFILE_ARIB_PROFILE_C:
+    case AV_PROFILE_ARIB_PROFILE_C:
         profile = ARIBCC_PROFILE_C;
         ctx->plane_width = 320;
         ctx->plane_height = 180;
diff --git a/libavcodec/libfdk-aacenc.c b/libavcodec/libfdk-aacenc.c
index e08c6a0c6c..d400ac2e7c 100644
--- a/libavcodec/libfdk-aacenc.c
+++ b/libavcodec/libfdk-aacenc.c
@@ -179,7 +179,7 @@ static av_cold int aac_encode_init(AVCodecContext *avctx)
     AACENC_InfoStruct info = { 0 };
     CHANNEL_MODE mode;
     AACENC_ERROR err;
-    int aot = FF_PROFILE_AAC_LOW + 1;
+    int aot = AV_PROFILE_AAC_LOW + 1;
     int sce = 0, cpe = 0;
 
     if ((err = aacEncOpen(&s->handle, 0, avctx->ch_layout.nb_channels)) != AACENC_OK) {
@@ -188,7 +188,7 @@ static av_cold int aac_encode_init(AVCodecContext *avctx)
         goto error;
     }
 
-    if (avctx->profile != FF_PROFILE_UNKNOWN)
+    if (avctx->profile != AV_PROFILE_UNKNOWN)
         aot = avctx->profile + 1;
 
     if ((err = aacEncoder_SetParam(s->handle, AACENC_AOT, aot)) != AACENC_OK) {
@@ -197,7 +197,7 @@ static av_cold int aac_encode_init(AVCodecContext *avctx)
         goto error;
     }
 
-    if (aot == FF_PROFILE_AAC_ELD + 1 && s->eld_sbr) {
+    if (aot == AV_PROFILE_AAC_ELD + 1 && s->eld_sbr) {
         if ((err = aacEncoder_SetParam(s->handle, AACENC_SBR_MODE,
                                        1)) != AACENC_OK) {
             av_log(avctx, AV_LOG_ERROR, "Unable to enable SBR for ELD: %s\n",
@@ -227,7 +227,7 @@ static av_cold int aac_encode_init(AVCodecContext *avctx)
     case 2:
 #if FDKENC_VER_AT_LEAST(4, 0) // 4.0.0
       // (profile + 1) to map from profile range to AOT range
-      if (aot == FF_PROFILE_AAC_ELD + 1 && s->eld_v2) {
+      if (aot == AV_PROFILE_AAC_ELD + 1 && s->eld_v2) {
           if ((err = aacEncoder_SetParam(s->handle, AACENC_CHANNELMODE,
                                          128)) != AACENC_OK) {
               av_log(avctx, AV_LOG_ERROR, "Unable to enable ELDv2: %s\n",
@@ -310,14 +310,14 @@ static av_cold int aac_encode_init(AVCodecContext *avctx)
         }
     } else {
         if (avctx->bit_rate <= 0) {
-            if (avctx->profile == FF_PROFILE_AAC_HE_V2) {
+            if (avctx->profile == AV_PROFILE_AAC_HE_V2) {
                 sce = 1;
                 cpe = 0;
             }
             avctx->bit_rate = (96*sce + 128*cpe) * avctx->sample_rate / 44;
-            if (avctx->profile == FF_PROFILE_AAC_HE ||
-                avctx->profile == FF_PROFILE_AAC_HE_V2 ||
-                avctx->profile == FF_PROFILE_MPEG2_AAC_HE ||
+            if (avctx->profile == AV_PROFILE_AAC_HE ||
+                avctx->profile == AV_PROFILE_AAC_HE_V2 ||
+                avctx->profile == AV_PROFILE_MPEG2_AAC_HE ||
                 s->eld_sbr)
                 avctx->bit_rate /= 2;
         }
@@ -544,12 +544,12 @@ static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
 }
 
 static const AVProfile profiles[] = {
-    { FF_PROFILE_AAC_LOW,   "LC"       },
-    { FF_PROFILE_AAC_HE,    "HE-AAC"   },
-    { FF_PROFILE_AAC_HE_V2, "HE-AACv2" },
-    { FF_PROFILE_AAC_LD,    "LD"       },
-    { FF_PROFILE_AAC_ELD,   "ELD"      },
-    { FF_PROFILE_UNKNOWN },
+    { AV_PROFILE_AAC_LOW,   "LC"       },
+    { AV_PROFILE_AAC_HE,    "HE-AAC"   },
+    { AV_PROFILE_AAC_HE_V2, "HE-AACv2" },
+    { AV_PROFILE_AAC_LD,    "LD"       },
+    { AV_PROFILE_AAC_ELD,   "ELD"      },
+    { AV_PROFILE_UNKNOWN },
 };
 
 static const FFCodecDefault aac_encode_defaults[] = {
diff --git a/libavcodec/libopenh264enc.c b/libavcodec/libopenh264enc.c
index 433accba22..f518d0894e 100644
--- a/libavcodec/libopenh264enc.c
+++ b/libavcodec/libopenh264enc.c
@@ -61,11 +61,11 @@ typedef struct SVCContext {
 #define DEPRECATED AV_OPT_FLAG_DEPRECATED
 static const AVOption options[] = {
     { "loopfilter", "enable loop filter", OFFSET(loopfilter), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, VE },
-    { "profile", "set profile restrictions", OFFSET(profile), AV_OPT_TYPE_INT, { .i64 = FF_PROFILE_UNKNOWN }, FF_PROFILE_UNKNOWN, 0xffff, VE, "profile" },
+    { "profile", "set profile restrictions", OFFSET(profile), AV_OPT_TYPE_INT, { .i64 = AV_PROFILE_UNKNOWN }, AV_PROFILE_UNKNOWN, 0xffff, VE, "profile" },
 #define PROFILE(name, value)  name, NULL, 0, AV_OPT_TYPE_CONST, { .i64 = value }, 0, 0, VE, "profile"
-        { PROFILE("constrained_baseline", FF_PROFILE_H264_CONSTRAINED_BASELINE) },
-        { PROFILE("main",                 FF_PROFILE_H264_MAIN) },
-        { PROFILE("high",                 FF_PROFILE_H264_HIGH) },
+        { PROFILE("constrained_baseline", AV_PROFILE_H264_CONSTRAINED_BASELINE) },
+        { PROFILE("main",                 AV_PROFILE_H264_MAIN) },
+        { PROFILE("high",                 AV_PROFILE_H264_HIGH) },
 #undef PROFILE
     { "max_nal_size", "set maximum NAL size in bytes", OFFSET(max_nal_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
     { "allow_skip_frames", "allow skipping frames to hit the target bitrate", OFFSET(skip_frames), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
@@ -177,12 +177,12 @@ FF_ENABLE_DEPRECATION_WARNINGS
     param.iMultipleThreadIdc         = avctx->thread_count;
 
     /* Allow specifying the libopenh264 profile through AVCodecContext. */
-    if (FF_PROFILE_UNKNOWN == s->profile &&
-        FF_PROFILE_UNKNOWN != avctx->profile)
+    if (AV_PROFILE_UNKNOWN == s->profile &&
+        AV_PROFILE_UNKNOWN != avctx->profile)
         switch (avctx->profile) {
-        case FF_PROFILE_H264_HIGH:
-        case FF_PROFILE_H264_MAIN:
-        case FF_PROFILE_H264_CONSTRAINED_BASELINE:
+        case AV_PROFILE_H264_HIGH:
+        case AV_PROFILE_H264_MAIN:
+        case AV_PROFILE_H264_CONSTRAINED_BASELINE:
             s->profile = avctx->profile;
             break;
         default:
@@ -191,34 +191,34 @@ FF_ENABLE_DEPRECATION_WARNINGS
             break;
         }
 
-    if (s->profile == FF_PROFILE_UNKNOWN && s->coder >= 0)
-        s->profile = s->coder == 0 ? FF_PROFILE_H264_CONSTRAINED_BASELINE :
+    if (s->profile == AV_PROFILE_UNKNOWN && s->coder >= 0)
+        s->profile = s->coder == 0 ? AV_PROFILE_H264_CONSTRAINED_BASELINE :
 #if OPENH264_VER_AT_LEAST(1, 8)
-                                     FF_PROFILE_H264_HIGH;
+                                     AV_PROFILE_H264_HIGH;
 #else
-                                     FF_PROFILE_H264_MAIN;
+                                     AV_PROFILE_H264_MAIN;
 #endif
 
     switch (s->profile) {
-    case FF_PROFILE_H264_HIGH:
+    case AV_PROFILE_H264_HIGH:
         av_log(avctx, AV_LOG_VERBOSE, "Using %s, "
                 "select EProfileIdc PRO_HIGH in libopenh264.\n",
                 param.iEntropyCodingModeFlag ? "CABAC" : "CAVLC");
         break;
-    case FF_PROFILE_H264_MAIN:
+    case AV_PROFILE_H264_MAIN:
         av_log(avctx, AV_LOG_VERBOSE, "Using %s, "
                 "select EProfileIdc PRO_MAIN in libopenh264.\n",
                 param.iEntropyCodingModeFlag ? "CABAC" : "CAVLC");
         break;
-    case FF_PROFILE_H264_CONSTRAINED_BASELINE:
-    case FF_PROFILE_UNKNOWN:
-        s->profile = FF_PROFILE_H264_CONSTRAINED_BASELINE;
+    case AV_PROFILE_H264_CONSTRAINED_BASELINE:
+    case AV_PROFILE_UNKNOWN:
+        s->profile = AV_PROFILE_H264_CONSTRAINED_BASELINE;
         param.iEntropyCodingModeFlag = 0;
         av_log(avctx, AV_LOG_VERBOSE, "Using CAVLC, "
                "select EProfileIdc PRO_BASELINE in libopenh264.\n");
         break;
     default:
-        s->profile = FF_PROFILE_H264_CONSTRAINED_BASELINE;
+        s->profile = AV_PROFILE_H264_CONSTRAINED_BASELINE;
         param.iEntropyCodingModeFlag = 0;
         av_log(avctx, AV_LOG_WARNING, "Unsupported profile, "
                "select EProfileIdc PRO_BASELINE in libopenh264.\n");
diff --git a/libavcodec/libsvtav1.c b/libavcodec/libsvtav1.c
index a8b3b62b96..5015169244 100644
--- a/libavcodec/libsvtav1.c
+++ b/libavcodec/libsvtav1.c
@@ -236,10 +236,10 @@ static int config_enc_params(EbSvtAv1EncConfiguration *param,
     }
 #endif
 
-    if (avctx->profile != FF_PROFILE_UNKNOWN)
+    if (avctx->profile != AV_PROFILE_UNKNOWN)
         param->profile = avctx->profile;
 
-    if (avctx->level != FF_LEVEL_UNKNOWN)
+    if (avctx->level != AV_LEVEL_UNKNOWN)
         param->level = avctx->level;
 
     // gop_size == 1 case is handled when encoding each frame by setting
@@ -310,12 +310,12 @@ FF_ENABLE_DEPRECATION_WARNINGS
     }
 
     if ((param->encoder_color_format == EB_YUV422 || param->encoder_bit_depth > 10)
-         && param->profile != FF_PROFILE_AV1_PROFESSIONAL ) {
+         && param->profile != AV_PROFILE_AV1_PROFESSIONAL ) {
         av_log(avctx, AV_LOG_WARNING, "Forcing Professional profile\n");
-        param->profile = FF_PROFILE_AV1_PROFESSIONAL;
-    } else if (param->encoder_color_format == EB_YUV444 && param->profile != FF_PROFILE_AV1_HIGH) {
+        param->profile = AV_PROFILE_AV1_PROFESSIONAL;
+    } else if (param->encoder_color_format == EB_YUV444 && param->profile != AV_PROFILE_AV1_HIGH) {
         av_log(avctx, AV_LOG_WARNING, "Forcing High profile\n");
-        param->profile = FF_PROFILE_AV1_HIGH;
+        param->profile = AV_PROFILE_AV1_HIGH;
     }
 
     avctx->bit_rate       = param->rate_control_mode > 0 ?
diff --git a/libavcodec/libvpxdec.c b/libavcodec/libvpxdec.c
index f480545ae0..40c8caf887 100644
--- a/libavcodec/libvpxdec.c
+++ b/libavcodec/libvpxdec.c
@@ -127,26 +127,26 @@ static int set_pix_fmt(AVCodecContext *avctx, struct vpx_image *img,
     switch (img->fmt) {
     case VPX_IMG_FMT_I420:
         if (avctx->codec_id == AV_CODEC_ID_VP9)
-            avctx->profile = FF_PROFILE_VP9_0;
+            avctx->profile = AV_PROFILE_VP9_0;
         avctx->pix_fmt =
             has_alpha_channel ? AV_PIX_FMT_YUVA420P : AV_PIX_FMT_YUV420P;
         return 0;
 #if CONFIG_LIBVPX_VP9_DECODER
     case VPX_IMG_FMT_I422:
-        avctx->profile = FF_PROFILE_VP9_1;
+        avctx->profile = AV_PROFILE_VP9_1;
         avctx->pix_fmt = AV_PIX_FMT_YUV422P;
         return 0;
     case VPX_IMG_FMT_I440:
-        avctx->profile = FF_PROFILE_VP9_1;
+        avctx->profile = AV_PROFILE_VP9_1;
         avctx->pix_fmt = AV_PIX_FMT_YUV440P;
         return 0;
     case VPX_IMG_FMT_I444:
-        avctx->profile = FF_PROFILE_VP9_1;
+        avctx->profile = AV_PROFILE_VP9_1;
         avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ?
                          AV_PIX_FMT_GBRP : AV_PIX_FMT_YUV444P;
         return 0;
     case VPX_IMG_FMT_I42016:
-        avctx->profile = FF_PROFILE_VP9_2;
+        avctx->profile = AV_PROFILE_VP9_2;
         if (img->bit_depth == 10) {
             avctx->pix_fmt = AV_PIX_FMT_YUV420P10;
             return 0;
@@ -157,7 +157,7 @@ static int set_pix_fmt(AVCodecContext *avctx, struct vpx_image *img,
             return AVERROR_INVALIDDATA;
         }
     case VPX_IMG_FMT_I42216:
-        avctx->profile = FF_PROFILE_VP9_3;
+        avctx->profile = AV_PROFILE_VP9_3;
         if (img->bit_depth == 10) {
             avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
             return 0;
@@ -168,7 +168,7 @@ static int set_pix_fmt(AVCodecContext *avctx, struct vpx_image *img,
             return AVERROR_INVALIDDATA;
         }
     case VPX_IMG_FMT_I44016:
-        avctx->profile = FF_PROFILE_VP9_3;
+        avctx->profile = AV_PROFILE_VP9_3;
         if (img->bit_depth == 10) {
             avctx->pix_fmt = AV_PIX_FMT_YUV440P10;
             return 0;
@@ -179,7 +179,7 @@ static int set_pix_fmt(AVCodecContext *avctx, struct vpx_image *img,
             return AVERROR_INVALIDDATA;
         }
     case VPX_IMG_FMT_I44416:
-        avctx->profile = FF_PROFILE_VP9_3;
+        avctx->profile = AV_PROFILE_VP9_3;
         if (img->bit_depth == 10) {
             avctx->pix_fmt = avctx->colorspace == AVCOL_SPC_RGB ?
                              AV_PIX_FMT_GBRP10 : AV_PIX_FMT_YUV444P10;
diff --git a/libavcodec/libvpxenc.c b/libavcodec/libvpxenc.c
index 0f6f4e785c..80988a2608 100644
--- a/libavcodec/libvpxenc.c
+++ b/libavcodec/libvpxenc.c
@@ -1145,7 +1145,7 @@ static av_cold int vpx_init(AVCodecContext *avctx,
     /* 0-3: For non-zero values the encoder increasingly optimizes for reduced
        complexity playback on low powered devices at the expense of encode
        quality. */
-    if (avctx->profile != FF_PROFILE_UNKNOWN)
+    if (avctx->profile != AV_PROFILE_UNKNOWN)
         enccfg.g_profile = avctx->profile;
 
     enccfg.g_error_resilient = ctx->error_resilient || ctx->flags & VP8F_ERROR_RESILIENT;
diff --git a/libavcodec/libx264.c b/libavcodec/libx264.c
index fb3186ca8d..77a9f173b4 100644
--- a/libavcodec/libx264.c
+++ b/libavcodec/libx264.c
@@ -1048,22 +1048,22 @@ static av_cold int X264_init(AVCodecContext *avctx)
     /* Allow specifying the x264 profile through AVCodecContext. */
     if (!x4->profile)
         switch (avctx->profile) {
-        case FF_PROFILE_H264_BASELINE:
+        case AV_PROFILE_H264_BASELINE:
             x4->profile = "baseline";
             break;
-        case FF_PROFILE_H264_HIGH:
+        case AV_PROFILE_H264_HIGH:
             x4->profile = "high";
             break;
-        case FF_PROFILE_H264_HIGH_10:
+        case AV_PROFILE_H264_HIGH_10:
             x4->profile = "high10";
             break;
-        case FF_PROFILE_H264_HIGH_422:
+        case AV_PROFILE_H264_HIGH_422:
             x4->profile = "high422";
             break;
-        case FF_PROFILE_H264_HIGH_444:
+        case AV_PROFILE_H264_HIGH_444:
             x4->profile = "high444";
             break;
-        case FF_PROFILE_H264_MAIN:
+        case AV_PROFILE_H264_MAIN:
             x4->profile = "main";
             break;
         default:
diff --git a/libavcodec/mediacodec_wrapper.c b/libavcodec/mediacodec_wrapper.c
index eb69ad7eaf..0880ddd3ef 100644
--- a/libavcodec/mediacodec_wrapper.c
+++ b/libavcodec/mediacodec_wrapper.c
@@ -365,82 +365,82 @@ int ff_AMediaCodecProfile_getProfileFromAVCodecContext(AVCodecContext *avctx)
 
     if (avctx->codec_id == AV_CODEC_ID_H264) {
         switch(avctx->profile) {
-        case FF_PROFILE_H264_BASELINE:
+        case AV_PROFILE_H264_BASELINE:
             return AVCProfileBaseline;
-        case FF_PROFILE_H264_CONSTRAINED_BASELINE:
+        case AV_PROFILE_H264_CONSTRAINED_BASELINE:
             return AVCProfileConstrainedBaseline;
-        case FF_PROFILE_H264_MAIN:
+        case AV_PROFILE_H264_MAIN:
             return AVCProfileMain;
             break;
-        case FF_PROFILE_H264_EXTENDED:
+        case AV_PROFILE_H264_EXTENDED:
             return AVCProfileExtended;
-        case FF_PROFILE_H264_HIGH:
+        case AV_PROFILE_H264_HIGH:
             return AVCProfileHigh;
-        case FF_PROFILE_H264_HIGH_10:
-        case FF_PROFILE_H264_HIGH_10_INTRA:
+        case AV_PROFILE_H264_HIGH_10:
+        case AV_PROFILE_H264_HIGH_10_INTRA:
             return AVCProfileHigh10;
-        case FF_PROFILE_H264_HIGH_422:
-        case FF_PROFILE_H264_HIGH_422_INTRA:
+        case AV_PROFILE_H264_HIGH_422:
+        case AV_PROFILE_H264_HIGH_422_INTRA:
             return AVCProfileHigh422;
-        case FF_PROFILE_H264_HIGH_444:
-        case FF_PROFILE_H264_HIGH_444_INTRA:
-        case FF_PROFILE_H264_HIGH_444_PREDICTIVE:
+        case AV_PROFILE_H264_HIGH_444:
+        case AV_PROFILE_H264_HIGH_444_INTRA:
+        case AV_PROFILE_H264_HIGH_444_PREDICTIVE:
             return AVCProfileHigh444;
         }
     } else if (avctx->codec_id == AV_CODEC_ID_HEVC) {
         switch (avctx->profile) {
-        case FF_PROFILE_HEVC_MAIN:
+        case AV_PROFILE_HEVC_MAIN:
             return HEVCProfileMain;
-        case FF_PROFILE_HEVC_MAIN_STILL_PICTURE:
+        case AV_PROFILE_HEVC_MAIN_STILL_PICTURE:
             return HEVCProfileMainStill;
-        case FF_PROFILE_HEVC_MAIN_10:
+        case AV_PROFILE_HEVC_MAIN_10:
             return HEVCProfileMain10;
         }
     } else if (avctx->codec_id == AV_CODEC_ID_VP9) {
         switch (avctx->profile) {
-        case FF_PROFILE_VP9_0:
+        case AV_PROFILE_VP9_0:
             return VP9Profile0;
-        case FF_PROFILE_VP9_1:
+        case AV_PROFILE_VP9_1:
             return VP9Profile1;
-        case FF_PROFILE_VP9_2:
+        case AV_PROFILE_VP9_2:
             return VP9Profile2;
-         case FF_PROFILE_VP9_3:
+         case AV_PROFILE_VP9_3:
             return VP9Profile3;
         }
     } else if(avctx->codec_id == AV_CODEC_ID_MPEG4) {
         switch (avctx->profile)
         {
-        case FF_PROFILE_MPEG4_SIMPLE:
+        case AV_PROFILE_MPEG4_SIMPLE:
             return MPEG4ProfileSimple;
-        case FF_PROFILE_MPEG4_SIMPLE_SCALABLE:
+        case AV_PROFILE_MPEG4_SIMPLE_SCALABLE:
             return MPEG4ProfileSimpleScalable;
-        case FF_PROFILE_MPEG4_CORE:
+        case AV_PROFILE_MPEG4_CORE:
             return MPEG4ProfileCore;
-        case FF_PROFILE_MPEG4_MAIN:
+        case AV_PROFILE_MPEG4_MAIN:
             return MPEG4ProfileMain;
-        case FF_PROFILE_MPEG4_N_BIT:
+        case AV_PROFILE_MPEG4_N_BIT:
             return MPEG4ProfileNbit;
-        case FF_PROFILE_MPEG4_SCALABLE_TEXTURE:
+        case AV_PROFILE_MPEG4_SCALABLE_TEXTURE:
             return MPEG4ProfileScalableTexture;
-        case FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION:
+        case AV_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION:
             return MPEG4ProfileSimpleFBA;
-        case FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE:
+        case AV_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE:
             return MPEG4ProfileBasicAnimated;
-        case FF_PROFILE_MPEG4_HYBRID:
+        case AV_PROFILE_MPEG4_HYBRID:
             return MPEG4ProfileHybrid;
-        case FF_PROFILE_MPEG4_ADVANCED_REAL_TIME:
+        case AV_PROFILE_MPEG4_ADVANCED_REAL_TIME:
             return MPEG4ProfileAdvancedRealTime;
-        case FF_PROFILE_MPEG4_CORE_SCALABLE:
+        case AV_PROFILE_MPEG4_CORE_SCALABLE:
             return MPEG4ProfileCoreScalable;
-        case FF_PROFILE_MPEG4_ADVANCED_CODING:
+        case AV_PROFILE_MPEG4_ADVANCED_CODING:
             return MPEG4ProfileAdvancedCoding;
-        case FF_PROFILE_MPEG4_ADVANCED_CORE:
+        case AV_PROFILE_MPEG4_ADVANCED_CORE:
             return MPEG4ProfileAdvancedCore;
-        case FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE:
+        case AV_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE:
             return MPEG4ProfileAdvancedScalable;
-        case FF_PROFILE_MPEG4_ADVANCED_SIMPLE:
+        case AV_PROFILE_MPEG4_ADVANCED_SIMPLE:
             return MPEG4ProfileAdvancedSimple;
-        case FF_PROFILE_MPEG4_SIMPLE_STUDIO:
+        case AV_PROFILE_MPEG4_SIMPLE_STUDIO:
             // Studio profiles are not supported by mediacodec.
         default:
             break;
@@ -448,10 +448,10 @@ int ff_AMediaCodecProfile_getProfileFromAVCodecContext(AVCodecContext *avctx)
     } else if(avctx->codec_id == AV_CODEC_ID_AV1) {
         switch (avctx->profile)
         {
-        case FF_PROFILE_AV1_MAIN:
+        case AV_PROFILE_AV1_MAIN:
             return AV1ProfileMain8;
-        case FF_PROFILE_AV1_HIGH:
-        case FF_PROFILE_AV1_PROFESSIONAL:
+        case AV_PROFILE_AV1_HIGH:
+        case AV_PROFILE_AV1_PROFESSIONAL:
         default:
             break;
         }
diff --git a/libavcodec/mediacodecenc.c b/libavcodec/mediacodecenc.c
index 1da705d113..485ab7b4ed 100644
--- a/libavcodec/mediacodecenc.c
+++ b/libavcodec/mediacodecenc.c
@@ -660,14 +660,14 @@ enum MediaCodecAvcLevel {
 static const AVOption h264_options[] = {
     COMMON_OPTION
 
-    FF_AVCTX_PROFILE_OPTION("baseline",             NULL, VIDEO, FF_PROFILE_H264_BASELINE)
-    FF_AVCTX_PROFILE_OPTION("constrained_baseline", NULL, VIDEO, FF_PROFILE_H264_CONSTRAINED_BASELINE)
-    FF_AVCTX_PROFILE_OPTION("main",                 NULL, VIDEO, FF_PROFILE_H264_MAIN)
-    FF_AVCTX_PROFILE_OPTION("extended",             NULL, VIDEO, FF_PROFILE_H264_EXTENDED)
-    FF_AVCTX_PROFILE_OPTION("high",                 NULL, VIDEO, FF_PROFILE_H264_HIGH)
-    FF_AVCTX_PROFILE_OPTION("high10",               NULL, VIDEO, FF_PROFILE_H264_HIGH_10)
-    FF_AVCTX_PROFILE_OPTION("high422",              NULL, VIDEO, FF_PROFILE_H264_HIGH_422)
-    FF_AVCTX_PROFILE_OPTION("high444",              NULL, VIDEO, FF_PROFILE_H264_HIGH_444)
+    FF_AVCTX_PROFILE_OPTION("baseline",             NULL, VIDEO, AV_PROFILE_H264_BASELINE)
+    FF_AVCTX_PROFILE_OPTION("constrained_baseline", NULL, VIDEO, AV_PROFILE_H264_CONSTRAINED_BASELINE)
+    FF_AVCTX_PROFILE_OPTION("main",                 NULL, VIDEO, AV_PROFILE_H264_MAIN)
+    FF_AVCTX_PROFILE_OPTION("extended",             NULL, VIDEO, AV_PROFILE_H264_EXTENDED)
+    FF_AVCTX_PROFILE_OPTION("high",                 NULL, VIDEO, AV_PROFILE_H264_HIGH)
+    FF_AVCTX_PROFILE_OPTION("high10",               NULL, VIDEO, AV_PROFILE_H264_HIGH_10)
+    FF_AVCTX_PROFILE_OPTION("high422",              NULL, VIDEO, AV_PROFILE_H264_HIGH_422)
+    FF_AVCTX_PROFILE_OPTION("high444",              NULL, VIDEO, AV_PROFILE_H264_HIGH_444)
 
     { "level", "Specify level",
                 OFFSET(level), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, VE, "level" },
@@ -732,8 +732,8 @@ enum MediaCodecHevcLevel {
 static const AVOption hevc_options[] = {
     COMMON_OPTION
 
-    FF_AVCTX_PROFILE_OPTION("main",   NULL, VIDEO, FF_PROFILE_HEVC_MAIN)
-    FF_AVCTX_PROFILE_OPTION("main10", NULL, VIDEO, FF_PROFILE_HEVC_MAIN_10)
+    FF_AVCTX_PROFILE_OPTION("main",   NULL, VIDEO, AV_PROFILE_HEVC_MAIN)
+    FF_AVCTX_PROFILE_OPTION("main10", NULL, VIDEO, AV_PROFILE_HEVC_MAIN_10)
 
     { "level", "Specify tier and level",
                 OFFSET(level), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, VE, "level" },
@@ -846,10 +846,10 @@ enum MediaCodecVP9Level {
 static const AVOption vp9_options[] = {
     COMMON_OPTION
 
-    FF_AVCTX_PROFILE_OPTION("profile0",   NULL, VIDEO, FF_PROFILE_VP9_0)
-    FF_AVCTX_PROFILE_OPTION("profile1",   NULL, VIDEO, FF_PROFILE_VP9_1)
-    FF_AVCTX_PROFILE_OPTION("profile2",   NULL, VIDEO, FF_PROFILE_VP9_2)
-    FF_AVCTX_PROFILE_OPTION("profile3",   NULL, VIDEO, FF_PROFILE_VP9_3)
+    FF_AVCTX_PROFILE_OPTION("profile0",   NULL, VIDEO, AV_PROFILE_VP9_0)
+    FF_AVCTX_PROFILE_OPTION("profile1",   NULL, VIDEO, AV_PROFILE_VP9_1)
+    FF_AVCTX_PROFILE_OPTION("profile2",   NULL, VIDEO, AV_PROFILE_VP9_2)
+    FF_AVCTX_PROFILE_OPTION("profile3",   NULL, VIDEO, AV_PROFILE_VP9_3)
 
     { "level", "Specify tier and level",
                 OFFSET(level), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, VE, "level" },
diff --git a/libavcodec/mfenc.c b/libavcodec/mfenc.c
index 8d950a3109..3c50a6c074 100644
--- a/libavcodec/mfenc.c
+++ b/libavcodec/mfenc.c
@@ -672,10 +672,10 @@ FF_ENABLE_DEPRECATION_WARNINGS
     if (avctx->codec_id == AV_CODEC_ID_H264) {
         UINT32 profile = ff_eAVEncH264VProfile_Base;
         switch (avctx->profile) {
-        case FF_PROFILE_H264_MAIN:
+        case AV_PROFILE_H264_MAIN:
             profile = ff_eAVEncH264VProfile_Main;
             break;
-        case FF_PROFILE_H264_HIGH:
+        case AV_PROFILE_H264_HIGH:
             profile = ff_eAVEncH264VProfile_High;
             break;
         }
diff --git a/libavcodec/mjpegdec.c b/libavcodec/mjpegdec.c
index 0a8f3d68dd..29f281231c 100644
--- a/libavcodec/mjpegdec.c
+++ b/libavcodec/mjpegdec.c
@@ -2486,9 +2486,9 @@ redo_for_pal8:
         case SOF0:
         case SOF1:
             if (start_code == SOF0)
-                s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
+                s->avctx->profile = AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
             else
-                s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
+                s->avctx->profile = AV_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
             s->lossless    = 0;
             s->ls          = 0;
             s->progressive = 0;
@@ -2496,7 +2496,7 @@ redo_for_pal8:
                 goto fail;
             break;
         case SOF2:
-            s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
+            s->avctx->profile = AV_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
             s->lossless    = 0;
             s->ls          = 0;
             s->progressive = 1;
@@ -2504,7 +2504,7 @@ redo_for_pal8:
                 goto fail;
             break;
         case SOF3:
-            s->avctx->profile     = FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
+            s->avctx->profile     = AV_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
             s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
             s->lossless    = 1;
             s->ls          = 0;
@@ -2513,7 +2513,7 @@ redo_for_pal8:
                 goto fail;
             break;
         case SOF48:
-            s->avctx->profile     = FF_PROFILE_MJPEG_JPEG_LS;
+            s->avctx->profile     = AV_PROFILE_MJPEG_JPEG_LS;
             s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
             s->lossless    = 1;
             s->ls          = 1;
diff --git a/libavcodec/mlpdec.c b/libavcodec/mlpdec.c
index 966ee0f0a2..4357165d4e 100644
--- a/libavcodec/mlpdec.c
+++ b/libavcodec/mlpdec.c
@@ -398,7 +398,7 @@ static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
      */
     if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD
             && m->num_substreams == 4 && m->substream_info >> 7 == 1) {
-        m->avctx->profile     = FF_PROFILE_TRUEHD_ATMOS;
+        m->avctx->profile     = AV_PROFILE_TRUEHD_ATMOS;
     }
 
     /* limit to decoding 3 substreams, as the 4th is used by Dolby Atmos for non-audio data */
diff --git a/libavcodec/mpeg12enc.c b/libavcodec/mpeg12enc.c
index 4aa45e9e86..0135623c0e 100644
--- a/libavcodec/mpeg12enc.c
+++ b/libavcodec/mpeg12enc.c
@@ -203,23 +203,23 @@ static av_cold int encode_init(AVCodecContext *avctx)
         }
     }
 
-    if (avctx->profile == FF_PROFILE_UNKNOWN) {
-        if (avctx->level != FF_LEVEL_UNKNOWN) {
+    if (avctx->profile == AV_PROFILE_UNKNOWN) {
+        if (avctx->level != AV_LEVEL_UNKNOWN) {
             av_log(avctx, AV_LOG_ERROR, "Set profile and level\n");
             return AVERROR(EINVAL);
         }
         /* Main or 4:2:2 */
-        avctx->profile = avctx->pix_fmt == AV_PIX_FMT_YUV420P ? FF_PROFILE_MPEG2_MAIN
-                                                              : FF_PROFILE_MPEG2_422;
+        avctx->profile = avctx->pix_fmt == AV_PIX_FMT_YUV420P ? AV_PROFILE_MPEG2_MAIN
+                                                              : AV_PROFILE_MPEG2_422;
     }
-    if (avctx->level == FF_LEVEL_UNKNOWN) {
-        if (avctx->profile == FF_PROFILE_MPEG2_422) {   /* 4:2:2 */
+    if (avctx->level == AV_LEVEL_UNKNOWN) {
+        if (avctx->profile == AV_PROFILE_MPEG2_422) {   /* 4:2:2 */
             if (avctx->width <= 720 && avctx->height <= 608)
                 avctx->level = 5;                   /* Main */
             else
                 avctx->level = 2;                   /* High */
         } else {
-            if (avctx->profile != FF_PROFILE_MPEG2_HIGH &&
+            if (avctx->profile != AV_PROFILE_MPEG2_HIGH &&
                 avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
                 av_log(avctx, AV_LOG_ERROR,
                        "Only High(1) and 4:2:2(0) profiles support 4:2:2 color sampling\n");
@@ -366,7 +366,7 @@ static void mpeg1_encode_sequence_header(MpegEncContext *s)
         put_header(s, EXT_START_CODE);
         put_bits(&s->pb, 4, 1);                 // seq ext
 
-        put_bits(&s->pb, 1, s->avctx->profile == FF_PROFILE_MPEG2_422); // escx 1 for 4:2:2 profile
+        put_bits(&s->pb, 1, s->avctx->profile == AV_PROFILE_MPEG2_422); // escx 1 for 4:2:2 profile
 
         put_bits(&s->pb, 3, s->avctx->profile); // profile
         put_bits(&s->pb, 4, s->avctx->level);   // level
diff --git a/libavcodec/mpeg4videodec.c b/libavcodec/mpeg4videodec.c
index f7f0ff59e8..72bf9eb115 100644
--- a/libavcodec/mpeg4videodec.c
+++ b/libavcodec/mpeg4videodec.c
@@ -2564,10 +2564,10 @@ static int decode_vol_header(Mpeg4DecContext *ctx, GetBitContext *gb)
      */
     if (ctx->vo_type == CORE_STUDIO_VO_TYPE ||
         ctx->vo_type == SIMPLE_STUDIO_VO_TYPE) {
-        if (s->avctx->profile != FF_PROFILE_UNKNOWN && s->avctx->profile != FF_PROFILE_MPEG4_SIMPLE_STUDIO)
+        if (s->avctx->profile != AV_PROFILE_UNKNOWN && s->avctx->profile != AV_PROFILE_MPEG4_SIMPLE_STUDIO)
             return AVERROR_INVALIDDATA;
         s->studio_profile = 1;
-        s->avctx->profile = FF_PROFILE_MPEG4_SIMPLE_STUDIO;
+        s->avctx->profile = AV_PROFILE_MPEG4_SIMPLE_STUDIO;
         return decode_studio_vol_header(ctx, gb);
     } else if (s->studio_profile) {
         return AVERROR_PATCHWELCOME;
@@ -3605,7 +3605,7 @@ int ff_mpeg4_decode_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb,
         } else if (startcode == VOS_STARTCODE) {
             int profile, level;
             mpeg4_decode_profile_level(s, gb, &profile, &level);
-            if (profile == FF_PROFILE_MPEG4_SIMPLE_STUDIO &&
+            if (profile == AV_PROFILE_MPEG4_SIMPLE_STUDIO &&
                 (level > 0 && level < 9)) {
                 s->studio_profile = 1;
                 next_start_code_studio(gb);
diff --git a/libavcodec/mpeg4videoenc.c b/libavcodec/mpeg4videoenc.c
index 777635c40c..d1e50612dd 100644
--- a/libavcodec/mpeg4videoenc.c
+++ b/libavcodec/mpeg4videoenc.c
@@ -916,7 +916,7 @@ static void mpeg4_encode_visual_object_header(MpegEncContext *s)
     int profile_and_level_indication;
     int vo_ver_id;
 
-    if (s->avctx->profile != FF_PROFILE_UNKNOWN) {
+    if (s->avctx->profile != AV_PROFILE_UNKNOWN) {
         profile_and_level_indication = s->avctx->profile << 4;
     } else if (s->max_b_frames || s->quarter_sample) {
         profile_and_level_indication = 0xF0;  // adv simple
@@ -924,7 +924,7 @@ static void mpeg4_encode_visual_object_header(MpegEncContext *s)
         profile_and_level_indication = 0x00;  // simple
     }
 
-    if (s->avctx->level != FF_LEVEL_UNKNOWN)
+    if (s->avctx->level != AV_LEVEL_UNKNOWN)
         profile_and_level_indication |= s->avctx->level;
     else
         profile_and_level_indication |= 1;   // level 1
diff --git a/libavcodec/nvenc.c b/libavcodec/nvenc.c
index 4249ff7188..9875f02dc8 100644
--- a/libavcodec/nvenc.c
+++ b/libavcodec/nvenc.c
@@ -1219,19 +1219,19 @@ static av_cold int nvenc_setup_h264_config(AVCodecContext *avctx)
         switch(ctx->profile) {
         case NV_ENC_H264_PROFILE_BASELINE:
             cc->profileGUID = NV_ENC_H264_PROFILE_BASELINE_GUID;
-            avctx->profile = FF_PROFILE_H264_BASELINE;
+            avctx->profile = AV_PROFILE_H264_BASELINE;
             break;
         case NV_ENC_H264_PROFILE_MAIN:
             cc->profileGUID = NV_ENC_H264_PROFILE_MAIN_GUID;
-            avctx->profile = FF_PROFILE_H264_MAIN;
+            avctx->profile = AV_PROFILE_H264_MAIN;
             break;
         case NV_ENC_H264_PROFILE_HIGH:
             cc->profileGUID = NV_ENC_H264_PROFILE_HIGH_GUID;
-            avctx->profile = FF_PROFILE_H264_HIGH;
+            avctx->profile = AV_PROFILE_H264_HIGH;
             break;
         case NV_ENC_H264_PROFILE_HIGH_444P:
             cc->profileGUID = NV_ENC_H264_PROFILE_HIGH_444_GUID;
-            avctx->profile = FF_PROFILE_H264_HIGH_444_PREDICTIVE;
+            avctx->profile = AV_PROFILE_H264_HIGH_444_PREDICTIVE;
             break;
         }
     }
@@ -1239,10 +1239,10 @@ static av_cold int nvenc_setup_h264_config(AVCodecContext *avctx)
     // force setting profile as high444p if input is AV_PIX_FMT_YUV444P
     if (IS_YUV444(ctx->data_pix_fmt)) {
         cc->profileGUID = NV_ENC_H264_PROFILE_HIGH_444_GUID;
-        avctx->profile = FF_PROFILE_H264_HIGH_444_PREDICTIVE;
+        avctx->profile = AV_PROFILE_H264_HIGH_444_PREDICTIVE;
     }
 
-    h264->chromaFormatIDC = avctx->profile == FF_PROFILE_H264_HIGH_444_PREDICTIVE ? 3 : 1;
+    h264->chromaFormatIDC = avctx->profile == AV_PROFILE_H264_HIGH_444_PREDICTIVE ? 3 : 1;
 
     h264->level = ctx->level;
 
@@ -1335,28 +1335,28 @@ static av_cold int nvenc_setup_hevc_config(AVCodecContext *avctx)
     switch (ctx->profile) {
     case NV_ENC_HEVC_PROFILE_MAIN:
         cc->profileGUID = NV_ENC_HEVC_PROFILE_MAIN_GUID;
-        avctx->profile  = FF_PROFILE_HEVC_MAIN;
+        avctx->profile  = AV_PROFILE_HEVC_MAIN;
         break;
     case NV_ENC_HEVC_PROFILE_MAIN_10:
         cc->profileGUID = NV_ENC_HEVC_PROFILE_MAIN10_GUID;
-        avctx->profile  = FF_PROFILE_HEVC_MAIN_10;
+        avctx->profile  = AV_PROFILE_HEVC_MAIN_10;
         break;
     case NV_ENC_HEVC_PROFILE_REXT:
         cc->profileGUID = NV_ENC_HEVC_PROFILE_FREXT_GUID;
-        avctx->profile  = FF_PROFILE_HEVC_REXT;
+        avctx->profile  = AV_PROFILE_HEVC_REXT;
         break;
     }
 
     // force setting profile as main10 if input is 10 bit
     if (IS_10BIT(ctx->data_pix_fmt)) {
         cc->profileGUID = NV_ENC_HEVC_PROFILE_MAIN10_GUID;
-        avctx->profile = FF_PROFILE_HEVC_MAIN_10;
+        avctx->profile = AV_PROFILE_HEVC_MAIN_10;
     }
 
     // force setting profile as rext if input is yuv444
     if (IS_YUV444(ctx->data_pix_fmt)) {
         cc->profileGUID = NV_ENC_HEVC_PROFILE_FREXT_GUID;
-        avctx->profile = FF_PROFILE_HEVC_REXT;
+        avctx->profile = AV_PROFILE_HEVC_REXT;
     }
 
     hevc->chromaFormatIDC = IS_YUV444(ctx->data_pix_fmt) ? 3 : 1;
@@ -1407,7 +1407,7 @@ static av_cold int nvenc_setup_av1_config(AVCodecContext *avctx)
         return AVERROR(ENOTSUP);
     } else {
         cc->profileGUID = NV_ENC_AV1_PROFILE_MAIN_GUID;
-        avctx->profile  = FF_PROFILE_AV1_MAIN;
+        avctx->profile  = AV_PROFILE_AV1_MAIN;
     }
 
     if (ctx->dpb_size >= 0) {
diff --git a/libavcodec/nvenc_hevc.c b/libavcodec/nvenc_hevc.c
index e606655e7e..e88f7e9783 100644
--- a/libavcodec/nvenc_hevc.c
+++ b/libavcodec/nvenc_hevc.c
@@ -57,7 +57,7 @@ static const AVOption options[] = {
     { "ull",         "Ultra low latency",                   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_TUNING_INFO_ULTRA_LOW_LATENCY },        0, 0, VE, "tune" },
     { "lossless",    "Lossless",                            0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_TUNING_INFO_LOSSLESS },                 0, 0, VE, "tune" },
 #endif
-    { "profile",      "Set the encoding profile",           OFFSET(profile),      AV_OPT_TYPE_INT,   { .i64 = NV_ENC_HEVC_PROFILE_MAIN }, NV_ENC_HEVC_PROFILE_MAIN, FF_PROFILE_HEVC_REXT, VE, "profile" },
+    { "profile",      "Set the encoding profile",           OFFSET(profile),      AV_OPT_TYPE_INT,   { .i64 = NV_ENC_HEVC_PROFILE_MAIN }, NV_ENC_HEVC_PROFILE_MAIN, AV_PROFILE_HEVC_REXT, VE, "profile" },
     { "main",         "",                                   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_HEVC_PROFILE_MAIN },    0, 0, VE, "profile" },
     { "main10",       "",                                   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_HEVC_PROFILE_MAIN_10 }, 0, 0, VE, "profile" },
     { "rext",         "",                                   0,                    AV_OPT_TYPE_CONST, { .i64 = NV_ENC_HEVC_PROFILE_REXT },    0, 0, VE, "profile" },
diff --git a/libavcodec/omx.c b/libavcodec/omx.c
index 6e667971ea..8d6519d141 100644
--- a/libavcodec/omx.c
+++ b/libavcodec/omx.c
@@ -531,14 +531,14 @@ static av_cold int omx_component_init(AVCodecContext *avctx, const char *role)
         CHECK(err);
         avc.nBFrames = 0;
         avc.nPFrames = avctx->gop_size - 1;
-        switch (s->profile == FF_PROFILE_UNKNOWN ? avctx->profile : s->profile) {
-        case FF_PROFILE_H264_BASELINE:
+        switch (s->profile == AV_PROFILE_UNKNOWN ? avctx->profile : s->profile) {
+        case AV_PROFILE_H264_BASELINE:
             avc.eProfile = OMX_VIDEO_AVCProfileBaseline;
             break;
-        case FF_PROFILE_H264_MAIN:
+        case AV_PROFILE_H264_MAIN:
             avc.eProfile = OMX_VIDEO_AVCProfileMain;
             break;
-        case FF_PROFILE_H264_HIGH:
+        case AV_PROFILE_H264_HIGH:
             avc.eProfile = OMX_VIDEO_AVCProfileHigh;
             break;
         default:
@@ -919,10 +919,10 @@ static const AVOption options[] = {
     { "omx_libname", "OpenMAX library name", OFFSET(libname), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
     { "omx_libprefix", "OpenMAX library prefix", OFFSET(libprefix), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VDE },
     { "zerocopy", "Try to avoid copying input frames if possible", OFFSET(input_zerocopy), AV_OPT_TYPE_INT, { .i64 = CONFIG_OMX_RPI }, 0, 1, VE },
-    { "profile",  "Set the encoding profile", OFFSET(profile), AV_OPT_TYPE_INT,   { .i64 = FF_PROFILE_UNKNOWN },       FF_PROFILE_UNKNOWN, FF_PROFILE_H264_HIGH, VE, "profile" },
-    { "baseline", "",                         0,               AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_BASELINE }, 0, 0, VE, "profile" },
-    { "main",     "",                         0,               AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_MAIN },     0, 0, VE, "profile" },
-    { "high",     "",                         0,               AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_HIGH },     0, 0, VE, "profile" },
+    { "profile",  "Set the encoding profile", OFFSET(profile), AV_OPT_TYPE_INT,   { .i64 = AV_PROFILE_UNKNOWN },       AV_PROFILE_UNKNOWN, AV_PROFILE_H264_HIGH, VE, "profile" },
+    { "baseline", "",                         0,               AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_H264_BASELINE }, 0, 0, VE, "profile" },
+    { "main",     "",                         0,               AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_H264_MAIN },     0, 0, VE, "profile" },
+    { "high",     "",                         0,               AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_H264_HIGH },     0, 0, VE, "profile" },
     { NULL }
 };
 
diff --git a/libavcodec/options_table.h b/libavcodec/options_table.h
index bb4b894b06..47e4a313bc 100644
--- a/libavcodec/options_table.h
+++ b/libavcodec/options_table.h
@@ -223,9 +223,9 @@ static const AVOption avcodec_options[] = {
 {"nssew", "nsse weight", OFFSET(nsse_weight), AV_OPT_TYPE_INT, {.i64 = 8 }, INT_MIN, INT_MAX, V|E},
 {"skip_top", "number of macroblock rows at the top which are skipped", OFFSET(skip_top), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|D},
 {"skip_bottom", "number of macroblock rows at the bottom which are skipped", OFFSET(skip_bottom), AV_OPT_TYPE_INT, {.i64 = DEFAULT }, INT_MIN, INT_MAX, V|D},
-{"profile", NULL, OFFSET(profile), AV_OPT_TYPE_INT, {.i64 = FF_PROFILE_UNKNOWN }, INT_MIN, INT_MAX, V|A|E|CC, "avctx.profile"},
-{"unknown", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "avctx.profile"},
-{"main10",  NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_HEVC_MAIN_10 }, INT_MIN, INT_MAX, V|E, "avctx.profile"},
+{"profile", NULL, OFFSET(profile), AV_OPT_TYPE_INT, {.i64 = AV_PROFILE_UNKNOWN }, INT_MIN, INT_MAX, V|A|E|CC, "avctx.profile"},
+{"unknown", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AV_PROFILE_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "avctx.profile"},
+{"main10",  NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AV_PROFILE_HEVC_MAIN_10 }, INT_MIN, INT_MAX, V|E, "avctx.profile"},
 {"level", NULL, OFFSET(level), AV_OPT_TYPE_INT, {.i64 = FF_LEVEL_UNKNOWN }, INT_MIN, INT_MAX, V|A|E|CC, "avctx.level"},
 {"unknown", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LEVEL_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "avctx.level"},
 {"lowres", "decode at 1= 1/2, 2=1/4, 3=1/8 resolutions", OFFSET(lowres), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, INT_MAX, V|A|D},
diff --git a/libavcodec/profiles.c b/libavcodec/profiles.c
index c646a3f54d..5bb8f150e6 100644
--- a/libavcodec/profiles.c
+++ b/libavcodec/profiles.c
@@ -24,180 +24,180 @@
 #if !CONFIG_SMALL
 
 const AVProfile ff_aac_profiles[] = {
-    { FF_PROFILE_AAC_LOW,   "LC"       },
-    { FF_PROFILE_AAC_HE,    "HE-AAC"   },
-    { FF_PROFILE_AAC_HE_V2, "HE-AACv2" },
-    { FF_PROFILE_AAC_LD,    "LD"       },
-    { FF_PROFILE_AAC_ELD,   "ELD"      },
-    { FF_PROFILE_AAC_MAIN,  "Main" },
-    { FF_PROFILE_AAC_SSR,   "SSR"  },
-    { FF_PROFILE_AAC_LTP,   "LTP"  },
-    { FF_PROFILE_UNKNOWN },
+    { AV_PROFILE_AAC_LOW,   "LC"       },
+    { AV_PROFILE_AAC_HE,    "HE-AAC"   },
+    { AV_PROFILE_AAC_HE_V2, "HE-AACv2" },
+    { AV_PROFILE_AAC_LD,    "LD"       },
+    { AV_PROFILE_AAC_ELD,   "ELD"      },
+    { AV_PROFILE_AAC_MAIN,  "Main" },
+    { AV_PROFILE_AAC_SSR,   "SSR"  },
+    { AV_PROFILE_AAC_LTP,   "LTP"  },
+    { AV_PROFILE_UNKNOWN },
 };
 
 const AVProfile ff_dca_profiles[] = {
-    { FF_PROFILE_DTS,                "DTS"                    },
-    { FF_PROFILE_DTS_ES,             "DTS-ES"                 },
-    { FF_PROFILE_DTS_96_24,          "DTS 96/24"              },
-    { FF_PROFILE_DTS_HD_HRA,         "DTS-HD HRA"             },
-    { FF_PROFILE_DTS_HD_MA,          "DTS-HD MA"              },
-    { FF_PROFILE_DTS_HD_MA_X,        "DTS-HD MA + DTS:X"      },
-    { FF_PROFILE_DTS_HD_MA_X_IMAX,   "DTS-HD MA + DTS:X IMAX" },
-    { FF_PROFILE_DTS_EXPRESS,        "DTS Express"            },
-    { FF_PROFILE_UNKNOWN },
+    { AV_PROFILE_DTS,                "DTS"                    },
+    { AV_PROFILE_DTS_ES,             "DTS-ES"                 },
+    { AV_PROFILE_DTS_96_24,          "DTS 96/24"              },
+    { AV_PROFILE_DTS_HD_HRA,         "DTS-HD HRA"             },
+    { AV_PROFILE_DTS_HD_MA,          "DTS-HD MA"              },
+    { AV_PROFILE_DTS_HD_MA_X,        "DTS-HD MA + DTS:X"      },
+    { AV_PROFILE_DTS_HD_MA_X_IMAX,   "DTS-HD MA + DTS:X IMAX" },
+    { AV_PROFILE_DTS_EXPRESS,        "DTS Express"            },
+    { AV_PROFILE_UNKNOWN },
 };
 
 const AVProfile ff_eac3_profiles[] = {
-  { FF_PROFILE_EAC3_DDP_ATMOS, "Dolby Digital Plus + Dolby Atmos"},
-  { FF_PROFILE_UNKNOWN },
+  { AV_PROFILE_EAC3_DDP_ATMOS, "Dolby Digital Plus + Dolby Atmos"},
+  { AV_PROFILE_UNKNOWN },
 };
 
 const AVProfile ff_truehd_profiles[] = {
-  { FF_PROFILE_TRUEHD_ATMOS,   "Dolby TrueHD + Dolby Atmos"},
-  { FF_PROFILE_UNKNOWN },
+  { AV_PROFILE_TRUEHD_ATMOS,   "Dolby TrueHD + Dolby Atmos"},
+  { AV_PROFILE_UNKNOWN },
 };
 
 const AVProfile ff_dnxhd_profiles[] = {
-  { FF_PROFILE_DNXHD,      "DNXHD"},
-  { FF_PROFILE_DNXHR_LB,   "DNXHR LB"},
-  { FF_PROFILE_DNXHR_SQ,   "DNXHR SQ"},
-  { FF_PROFILE_DNXHR_HQ,   "DNXHR HQ" },
-  { FF_PROFILE_DNXHR_HQX,  "DNXHR HQX"},
-  { FF_PROFILE_DNXHR_444,  "DNXHR 444"},
-  { FF_PROFILE_UNKNOWN },
+  { AV_PROFILE_DNXHD,      "DNXHD"},
+  { AV_PROFILE_DNXHR_LB,   "DNXHR LB"},
+  { AV_PROFILE_DNXHR_SQ,   "DNXHR SQ"},
+  { AV_PROFILE_DNXHR_HQ,   "DNXHR HQ" },
+  { AV_PROFILE_DNXHR_HQX,  "DNXHR HQX"},
+  { AV_PROFILE_DNXHR_444,  "DNXHR 444"},
+  { AV_PROFILE_UNKNOWN },
 };
 
 const AVProfile ff_h264_profiles[] = {
-    { FF_PROFILE_H264_BASELINE,             "Baseline"              },
-    { FF_PROFILE_H264_CONSTRAINED_BASELINE, "Constrained Baseline"  },
-    { FF_PROFILE_H264_MAIN,                 "Main"                  },
-    { FF_PROFILE_H264_EXTENDED,             "Extended"              },
-    { FF_PROFILE_H264_HIGH,                 "High"                  },
-    { FF_PROFILE_H264_HIGH_10,              "High 10"               },
-    { FF_PROFILE_H264_HIGH_10_INTRA,        "High 10 Intra"         },
-    { FF_PROFILE_H264_HIGH_422,             "High 4:2:2"            },
-    { FF_PROFILE_H264_HIGH_422_INTRA,       "High 4:2:2 Intra"      },
-    { FF_PROFILE_H264_HIGH_444,             "High 4:4:4"            },
-    { FF_PROFILE_H264_HIGH_444_PREDICTIVE,  "High 4:4:4 Predictive" },
-    { FF_PROFILE_H264_HIGH_444_INTRA,       "High 4:4:4 Intra"      },
-    { FF_PROFILE_H264_CAVLC_444,            "CAVLC 4:4:4"           },
-    { FF_PROFILE_H264_MULTIVIEW_HIGH,       "Multiview High"        },
-    { FF_PROFILE_H264_STEREO_HIGH,          "Stereo High"           },
-    { FF_PROFILE_UNKNOWN },
+    { AV_PROFILE_H264_BASELINE,             "Baseline"              },
+    { AV_PROFILE_H264_CONSTRAINED_BASELINE, "Constrained Baseline"  },
+    { AV_PROFILE_H264_MAIN,                 "Main"                  },
+    { AV_PROFILE_H264_EXTENDED,             "Extended"              },
+    { AV_PROFILE_H264_HIGH,                 "High"                  },
+    { AV_PROFILE_H264_HIGH_10,              "High 10"               },
+    { AV_PROFILE_H264_HIGH_10_INTRA,        "High 10 Intra"         },
+    { AV_PROFILE_H264_HIGH_422,             "High 4:2:2"            },
+    { AV_PROFILE_H264_HIGH_422_INTRA,       "High 4:2:2 Intra"      },
+    { AV_PROFILE_H264_HIGH_444,             "High 4:4:4"            },
+    { AV_PROFILE_H264_HIGH_444_PREDICTIVE,  "High 4:4:4 Predictive" },
+    { AV_PROFILE_H264_HIGH_444_INTRA,       "High 4:4:4 Intra"      },
+    { AV_PROFILE_H264_CAVLC_444,            "CAVLC 4:4:4"           },
+    { AV_PROFILE_H264_MULTIVIEW_HIGH,       "Multiview High"        },
+    { AV_PROFILE_H264_STEREO_HIGH,          "Stereo High"           },
+    { AV_PROFILE_UNKNOWN },
 };
 
 const AVProfile ff_vvc_profiles[] = {
-    { FF_PROFILE_VVC_MAIN_10,                   "Main 10" },
-    { FF_PROFILE_VVC_MAIN_10_444,               "Main 10 4:4:4" },
-    { FF_PROFILE_UNKNOWN },
+    { AV_PROFILE_VVC_MAIN_10,                   "Main 10" },
+    { AV_PROFILE_VVC_MAIN_10_444,               "Main 10 4:4:4" },
+    { AV_PROFILE_UNKNOWN },
 };
 
 const AVProfile ff_hevc_profiles[] = {
-    { FF_PROFILE_HEVC_MAIN,                 "Main"                },
-    { FF_PROFILE_HEVC_MAIN_10,              "Main 10"             },
-    { FF_PROFILE_HEVC_MAIN_STILL_PICTURE,   "Main Still Picture"  },
-    { FF_PROFILE_HEVC_REXT,                 "Rext"                },
-    { FF_PROFILE_HEVC_SCC,                  "Scc"                 },
-    { FF_PROFILE_UNKNOWN },
+    { AV_PROFILE_HEVC_MAIN,                 "Main"                },
+    { AV_PROFILE_HEVC_MAIN_10,              "Main 10"             },
+    { AV_PROFILE_HEVC_MAIN_STILL_PICTURE,   "Main Still Picture"  },
+    { AV_PROFILE_HEVC_REXT,                 "Rext"                },
+    { AV_PROFILE_HEVC_SCC,                  "Scc"                 },
+    { AV_PROFILE_UNKNOWN },
 };
 
 const AVProfile ff_jpeg2000_profiles[] = {
-    { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0,  "JPEG 2000 codestream restriction 0"   },
-    { FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1,  "JPEG 2000 codestream restriction 1"   },
-    { FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION, "JPEG 2000 no codestream restrictions" },
-    { FF_PROFILE_JPEG2000_DCINEMA_2K,             "JPEG 2000 digital cinema 2K"          },
-    { FF_PROFILE_JPEG2000_DCINEMA_4K,             "JPEG 2000 digital cinema 4K"          },
-    { FF_PROFILE_UNKNOWN },
+    { AV_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0,  "JPEG 2000 codestream restriction 0"   },
+    { AV_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1,  "JPEG 2000 codestream restriction 1"   },
+    { AV_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION, "JPEG 2000 no codestream restrictions" },
+    { AV_PROFILE_JPEG2000_DCINEMA_2K,             "JPEG 2000 digital cinema 2K"          },
+    { AV_PROFILE_JPEG2000_DCINEMA_4K,             "JPEG 2000 digital cinema 4K"          },
+    { AV_PROFILE_UNKNOWN },
 };
 
 const AVProfile ff_mpeg2_video_profiles[] = {
-    { FF_PROFILE_MPEG2_422,          "4:2:2"              },
-    { FF_PROFILE_MPEG2_HIGH,         "High"               },
-    { FF_PROFILE_MPEG2_SS,           "Spatially Scalable" },
-    { FF_PROFILE_MPEG2_SNR_SCALABLE, "SNR Scalable"       },
-    { FF_PROFILE_MPEG2_MAIN,         "Main"               },
-    { FF_PROFILE_MPEG2_SIMPLE,       "Simple"             },
-    { FF_PROFILE_RESERVED,           "Reserved"           },
-    { FF_PROFILE_UNKNOWN                                  },
+    { AV_PROFILE_MPEG2_422,          "4:2:2"              },
+    { AV_PROFILE_MPEG2_HIGH,         "High"               },
+    { AV_PROFILE_MPEG2_SS,           "Spatially Scalable" },
+    { AV_PROFILE_MPEG2_SNR_SCALABLE, "SNR Scalable"       },
+    { AV_PROFILE_MPEG2_MAIN,         "Main"               },
+    { AV_PROFILE_MPEG2_SIMPLE,       "Simple"             },
+    { AV_PROFILE_RESERVED,           "Reserved"           },
+    { AV_PROFILE_UNKNOWN                                  },
 };
 
 const AVProfile ff_mpeg4_video_profiles[] = {
-    { FF_PROFILE_MPEG4_SIMPLE,                    "Simple Profile" },
-    { FF_PROFILE_MPEG4_SIMPLE_SCALABLE,           "Simple Scalable Profile" },
-    { FF_PROFILE_MPEG4_CORE,                      "Core Profile" },
-    { FF_PROFILE_MPEG4_MAIN,                      "Main Profile" },
-    { FF_PROFILE_MPEG4_N_BIT,                     "N-bit Profile" },
-    { FF_PROFILE_MPEG4_SCALABLE_TEXTURE,          "Scalable Texture Profile" },
-    { FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION,     "Simple Face Animation Profile" },
-    { FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE,    "Basic Animated Texture Profile" },
-    { FF_PROFILE_MPEG4_HYBRID,                    "Hybrid Profile" },
-    { FF_PROFILE_MPEG4_ADVANCED_REAL_TIME,        "Advanced Real Time Simple Profile" },
-    { FF_PROFILE_MPEG4_CORE_SCALABLE,             "Code Scalable Profile" },
-    { FF_PROFILE_MPEG4_ADVANCED_CODING,           "Advanced Coding Profile" },
-    { FF_PROFILE_MPEG4_ADVANCED_CORE,             "Advanced Core Profile" },
-    { FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE, "Advanced Scalable Texture Profile" },
-    { FF_PROFILE_MPEG4_SIMPLE_STUDIO,             "Simple Studio Profile" },
-    { FF_PROFILE_MPEG4_ADVANCED_SIMPLE,           "Advanced Simple Profile" },
-    { FF_PROFILE_UNKNOWN },
+    { AV_PROFILE_MPEG4_SIMPLE,                    "Simple Profile" },
+    { AV_PROFILE_MPEG4_SIMPLE_SCALABLE,           "Simple Scalable Profile" },
+    { AV_PROFILE_MPEG4_CORE,                      "Core Profile" },
+    { AV_PROFILE_MPEG4_MAIN,                      "Main Profile" },
+    { AV_PROFILE_MPEG4_N_BIT,                     "N-bit Profile" },
+    { AV_PROFILE_MPEG4_SCALABLE_TEXTURE,          "Scalable Texture Profile" },
+    { AV_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION,     "Simple Face Animation Profile" },
+    { AV_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE,    "Basic Animated Texture Profile" },
+    { AV_PROFILE_MPEG4_HYBRID,                    "Hybrid Profile" },
+    { AV_PROFILE_MPEG4_ADVANCED_REAL_TIME,        "Advanced Real Time Simple Profile" },
+    { AV_PROFILE_MPEG4_CORE_SCALABLE,             "Code Scalable Profile" },
+    { AV_PROFILE_MPEG4_ADVANCED_CODING,           "Advanced Coding Profile" },
+    { AV_PROFILE_MPEG4_ADVANCED_CORE,             "Advanced Core Profile" },
+    { AV_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE, "Advanced Scalable Texture Profile" },
+    { AV_PROFILE_MPEG4_SIMPLE_STUDIO,             "Simple Studio Profile" },
+    { AV_PROFILE_MPEG4_ADVANCED_SIMPLE,           "Advanced Simple Profile" },
+    { AV_PROFILE_UNKNOWN },
 };
 
 const AVProfile ff_vc1_profiles[] = {
-    { FF_PROFILE_VC1_SIMPLE,   "Simple"   },
-    { FF_PROFILE_VC1_MAIN,     "Main"     },
-    { FF_PROFILE_VC1_COMPLEX,  "Complex"  },
-    { FF_PROFILE_VC1_ADVANCED, "Advanced" },
-    { FF_PROFILE_UNKNOWN },
+    { AV_PROFILE_VC1_SIMPLE,   "Simple"   },
+    { AV_PROFILE_VC1_MAIN,     "Main"     },
+    { AV_PROFILE_VC1_COMPLEX,  "Complex"  },
+    { AV_PROFILE_VC1_ADVANCED, "Advanced" },
+    { AV_PROFILE_UNKNOWN },
 };
 
 const AVProfile ff_vp9_profiles[] = {
-    { FF_PROFILE_VP9_0, "Profile 0" },
-    { FF_PROFILE_VP9_1, "Profile 1" },
-    { FF_PROFILE_VP9_2, "Profile 2" },
-    { FF_PROFILE_VP9_3, "Profile 3" },
-    { FF_PROFILE_UNKNOWN },
+    { AV_PROFILE_VP9_0, "Profile 0" },
+    { AV_PROFILE_VP9_1, "Profile 1" },
+    { AV_PROFILE_VP9_2, "Profile 2" },
+    { AV_PROFILE_VP9_3, "Profile 3" },
+    { AV_PROFILE_UNKNOWN },
 };
 
 const AVProfile ff_av1_profiles[] = {
-    { FF_PROFILE_AV1_MAIN,         "Main" },
-    { FF_PROFILE_AV1_HIGH,         "High" },
-    { FF_PROFILE_AV1_PROFESSIONAL, "Professional" },
-    { FF_PROFILE_UNKNOWN },
+    { AV_PROFILE_AV1_MAIN,         "Main" },
+    { AV_PROFILE_AV1_HIGH,         "High" },
+    { AV_PROFILE_AV1_PROFESSIONAL, "Professional" },
+    { AV_PROFILE_UNKNOWN },
 };
 
 const AVProfile ff_sbc_profiles[] = {
-    { FF_PROFILE_SBC_MSBC, "mSBC" },
-    { FF_PROFILE_UNKNOWN },
+    { AV_PROFILE_SBC_MSBC, "mSBC" },
+    { AV_PROFILE_UNKNOWN },
 };
 
 const AVProfile ff_prores_profiles[] = {
-    { FF_PROFILE_PRORES_PROXY,    "Proxy"    },
-    { FF_PROFILE_PRORES_LT,       "LT"       },
-    { FF_PROFILE_PRORES_STANDARD, "Standard" },
-    { FF_PROFILE_PRORES_HQ,       "HQ"       },
-    { FF_PROFILE_PRORES_4444,     "4444"     },
-    { FF_PROFILE_PRORES_XQ,       "XQ"       },
-    { FF_PROFILE_UNKNOWN }
+    { AV_PROFILE_PRORES_PROXY,    "Proxy"    },
+    { AV_PROFILE_PRORES_LT,       "LT"       },
+    { AV_PROFILE_PRORES_STANDARD, "Standard" },
+    { AV_PROFILE_PRORES_HQ,       "HQ"       },
+    { AV_PROFILE_PRORES_4444,     "4444"     },
+    { AV_PROFILE_PRORES_XQ,       "XQ"       },
+    { AV_PROFILE_UNKNOWN }
 };
 
 const AVProfile ff_mjpeg_profiles[] = {
-    { FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT,            "Baseline"    },
-    { FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT, "Sequential"  },
-    { FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT,         "Progressive" },
-    { FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS,                "Lossless"    },
-    { FF_PROFILE_MJPEG_JPEG_LS,                         "JPEG LS"     },
-    { FF_PROFILE_UNKNOWN }
+    { AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT,            "Baseline"    },
+    { AV_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT, "Sequential"  },
+    { AV_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT,         "Progressive" },
+    { AV_PROFILE_MJPEG_HUFFMAN_LOSSLESS,                "Lossless"    },
+    { AV_PROFILE_MJPEG_JPEG_LS,                         "JPEG LS"     },
+    { AV_PROFILE_UNKNOWN }
 };
 
 const AVProfile ff_arib_caption_profiles[] = {
-    { FF_PROFILE_ARIB_PROFILE_A, "Profile A" },
-    { FF_PROFILE_ARIB_PROFILE_C, "Profile C" },
-    { FF_PROFILE_UNKNOWN }
+    { AV_PROFILE_ARIB_PROFILE_A, "Profile A" },
+    { AV_PROFILE_ARIB_PROFILE_C, "Profile C" },
+    { AV_PROFILE_UNKNOWN }
 };
 
 const AVProfile ff_evc_profiles[] = {
-    { FF_PROFILE_EVC_BASELINE,             "Baseline"              },
-    { FF_PROFILE_EVC_MAIN,                 "Main"                  },
-    { FF_PROFILE_UNKNOWN },
+    { AV_PROFILE_EVC_BASELINE,             "Baseline"              },
+    { AV_PROFILE_EVC_MAIN,                 "Main"                  },
+    { AV_PROFILE_UNKNOWN },
 };
 
 #endif /* !CONFIG_SMALL */
diff --git a/libavcodec/profiles.h b/libavcodec/profiles.h
index c0eacae5c1..270430a48b 100644
--- a/libavcodec/profiles.h
+++ b/libavcodec/profiles.h
@@ -26,35 +26,35 @@
     {name, description, 0, AV_OPT_TYPE_CONST, {.i64 = value }, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_## type ##_PARAM, "avctx.profile"},
 
 #define FF_AAC_PROFILE_OPTS \
-    FF_AVCTX_PROFILE_OPTION("aac_main",      NULL, AUDIO, FF_PROFILE_AAC_MAIN)\
-    FF_AVCTX_PROFILE_OPTION("aac_low",       NULL, AUDIO, FF_PROFILE_AAC_LOW)\
-    FF_AVCTX_PROFILE_OPTION("aac_ssr",       NULL, AUDIO, FF_PROFILE_AAC_SSR)\
-    FF_AVCTX_PROFILE_OPTION("aac_ltp",       NULL, AUDIO, FF_PROFILE_AAC_LTP)\
-    FF_AVCTX_PROFILE_OPTION("aac_he",        NULL, AUDIO, FF_PROFILE_AAC_HE)\
-    FF_AVCTX_PROFILE_OPTION("aac_he_v2",     NULL, AUDIO, FF_PROFILE_AAC_HE_V2)\
-    FF_AVCTX_PROFILE_OPTION("aac_ld",        NULL, AUDIO, FF_PROFILE_AAC_LD)\
-    FF_AVCTX_PROFILE_OPTION("aac_eld",       NULL, AUDIO, FF_PROFILE_AAC_ELD)\
-    FF_AVCTX_PROFILE_OPTION("mpeg2_aac_low", NULL, AUDIO, FF_PROFILE_MPEG2_AAC_LOW)\
-    FF_AVCTX_PROFILE_OPTION("mpeg2_aac_he",  NULL, AUDIO, FF_PROFILE_MPEG2_AAC_HE)\
+    FF_AVCTX_PROFILE_OPTION("aac_main",      NULL, AUDIO, AV_PROFILE_AAC_MAIN)\
+    FF_AVCTX_PROFILE_OPTION("aac_low",       NULL, AUDIO, AV_PROFILE_AAC_LOW)\
+    FF_AVCTX_PROFILE_OPTION("aac_ssr",       NULL, AUDIO, AV_PROFILE_AAC_SSR)\
+    FF_AVCTX_PROFILE_OPTION("aac_ltp",       NULL, AUDIO, AV_PROFILE_AAC_LTP)\
+    FF_AVCTX_PROFILE_OPTION("aac_he",        NULL, AUDIO, AV_PROFILE_AAC_HE)\
+    FF_AVCTX_PROFILE_OPTION("aac_he_v2",     NULL, AUDIO, AV_PROFILE_AAC_HE_V2)\
+    FF_AVCTX_PROFILE_OPTION("aac_ld",        NULL, AUDIO, AV_PROFILE_AAC_LD)\
+    FF_AVCTX_PROFILE_OPTION("aac_eld",       NULL, AUDIO, AV_PROFILE_AAC_ELD)\
+    FF_AVCTX_PROFILE_OPTION("mpeg2_aac_low", NULL, AUDIO, AV_PROFILE_MPEG2_AAC_LOW)\
+    FF_AVCTX_PROFILE_OPTION("mpeg2_aac_he",  NULL, AUDIO, AV_PROFILE_MPEG2_AAC_HE)\
 
 #define FF_MPEG4_PROFILE_OPTS \
-    FF_AVCTX_PROFILE_OPTION("mpeg4_sp",      NULL, VIDEO, FF_PROFILE_MPEG4_SIMPLE)\
-    FF_AVCTX_PROFILE_OPTION("mpeg4_core",    NULL, VIDEO, FF_PROFILE_MPEG4_CORE)\
-    FF_AVCTX_PROFILE_OPTION("mpeg4_main",    NULL, VIDEO, FF_PROFILE_MPEG4_MAIN)\
-    FF_AVCTX_PROFILE_OPTION("mpeg4_asp",     NULL, VIDEO, FF_PROFILE_MPEG4_ADVANCED_SIMPLE)\
+    FF_AVCTX_PROFILE_OPTION("mpeg4_sp",      NULL, VIDEO, AV_PROFILE_MPEG4_SIMPLE)\
+    FF_AVCTX_PROFILE_OPTION("mpeg4_core",    NULL, VIDEO, AV_PROFILE_MPEG4_CORE)\
+    FF_AVCTX_PROFILE_OPTION("mpeg4_main",    NULL, VIDEO, AV_PROFILE_MPEG4_MAIN)\
+    FF_AVCTX_PROFILE_OPTION("mpeg4_asp",     NULL, VIDEO, AV_PROFILE_MPEG4_ADVANCED_SIMPLE)\
 
 #define FF_MPEG2_PROFILE_OPTS \
-    FF_AVCTX_PROFILE_OPTION("422",           NULL, VIDEO, FF_PROFILE_MPEG2_422)\
-    FF_AVCTX_PROFILE_OPTION("high",          NULL, VIDEO, FF_PROFILE_MPEG2_HIGH)\
-    FF_AVCTX_PROFILE_OPTION("ss",            NULL, VIDEO, FF_PROFILE_MPEG2_SS)\
-    FF_AVCTX_PROFILE_OPTION("snr",           NULL, VIDEO, FF_PROFILE_MPEG2_SNR_SCALABLE)\
-    FF_AVCTX_PROFILE_OPTION("main",          NULL, VIDEO, FF_PROFILE_MPEG2_MAIN)\
-    FF_AVCTX_PROFILE_OPTION("simple",        NULL, VIDEO, FF_PROFILE_MPEG2_SIMPLE)\
+    FF_AVCTX_PROFILE_OPTION("422",           NULL, VIDEO, AV_PROFILE_MPEG2_422)\
+    FF_AVCTX_PROFILE_OPTION("high",          NULL, VIDEO, AV_PROFILE_MPEG2_HIGH)\
+    FF_AVCTX_PROFILE_OPTION("ss",            NULL, VIDEO, AV_PROFILE_MPEG2_SS)\
+    FF_AVCTX_PROFILE_OPTION("snr",           NULL, VIDEO, AV_PROFILE_MPEG2_SNR_SCALABLE)\
+    FF_AVCTX_PROFILE_OPTION("main",          NULL, VIDEO, AV_PROFILE_MPEG2_MAIN)\
+    FF_AVCTX_PROFILE_OPTION("simple",        NULL, VIDEO, AV_PROFILE_MPEG2_SIMPLE)\
 
 #define FF_AV1_PROFILE_OPTS \
-    FF_AVCTX_PROFILE_OPTION("main",          NULL, VIDEO, FF_PROFILE_AV1_MAIN)\
-    FF_AVCTX_PROFILE_OPTION("high",          NULL, VIDEO, FF_PROFILE_AV1_HIGH)\
-    FF_AVCTX_PROFILE_OPTION("professional",  NULL, VIDEO, FF_PROFILE_AV1_PROFESSIONAL)\
+    FF_AVCTX_PROFILE_OPTION("main",          NULL, VIDEO, AV_PROFILE_AV1_MAIN)\
+    FF_AVCTX_PROFILE_OPTION("high",          NULL, VIDEO, AV_PROFILE_AV1_HIGH)\
+    FF_AVCTX_PROFILE_OPTION("professional",  NULL, VIDEO, AV_PROFILE_AV1_PROFESSIONAL)\
 
 extern const AVProfile ff_aac_profiles[];
 extern const AVProfile ff_dca_profiles[];
diff --git a/libavcodec/proresdec2.c b/libavcodec/proresdec2.c
index ae5838eca4..9297860946 100644
--- a/libavcodec/proresdec2.c
+++ b/libavcodec/proresdec2.c
@@ -141,27 +141,27 @@ static av_cold int decode_init(AVCodecContext *avctx)
 
     switch (avctx->codec_tag) {
     case MKTAG('a','p','c','o'):
-        avctx->profile = FF_PROFILE_PRORES_PROXY;
+        avctx->profile = AV_PROFILE_PRORES_PROXY;
         break;
     case MKTAG('a','p','c','s'):
-        avctx->profile = FF_PROFILE_PRORES_LT;
+        avctx->profile = AV_PROFILE_PRORES_LT;
         break;
     case MKTAG('a','p','c','n'):
-        avctx->profile = FF_PROFILE_PRORES_STANDARD;
+        avctx->profile = AV_PROFILE_PRORES_STANDARD;
         break;
     case MKTAG('a','p','c','h'):
-        avctx->profile = FF_PROFILE_PRORES_HQ;
+        avctx->profile = AV_PROFILE_PRORES_HQ;
         break;
     case MKTAG('a','p','4','h'):
-        avctx->profile = FF_PROFILE_PRORES_4444;
+        avctx->profile = AV_PROFILE_PRORES_4444;
         avctx->bits_per_raw_sample = 12;
         break;
     case MKTAG('a','p','4','x'):
-        avctx->profile = FF_PROFILE_PRORES_XQ;
+        avctx->profile = AV_PROFILE_PRORES_XQ;
         avctx->bits_per_raw_sample = 12;
         break;
     default:
-        avctx->profile = FF_PROFILE_UNKNOWN;
+        avctx->profile = AV_PROFILE_UNKNOWN;
         av_log(avctx, AV_LOG_WARNING, "Unknown prores profile %d\n", avctx->codec_tag);
     }
 
diff --git a/libavcodec/proresenc_anatoliy.c b/libavcodec/proresenc_anatoliy.c
index c701275e5d..e7114f1646 100644
--- a/libavcodec/proresenc_anatoliy.c
+++ b/libavcodec/proresenc_anatoliy.c
@@ -41,13 +41,13 @@
 #define DEFAULT_SLICE_MB_WIDTH 8
 
 static const AVProfile profiles[] = {
-    { FF_PROFILE_PRORES_PROXY,    "apco"},
-    { FF_PROFILE_PRORES_LT,       "apcs"},
-    { FF_PROFILE_PRORES_STANDARD, "apcn"},
-    { FF_PROFILE_PRORES_HQ,       "apch"},
-    { FF_PROFILE_PRORES_4444,     "ap4h"},
-    { FF_PROFILE_PRORES_XQ,       "ap4x"},
-    { FF_PROFILE_UNKNOWN }
+    { AV_PROFILE_PRORES_PROXY,    "apco"},
+    { AV_PROFILE_PRORES_LT,       "apcs"},
+    { AV_PROFILE_PRORES_STANDARD, "apcn"},
+    { AV_PROFILE_PRORES_HQ,       "apch"},
+    { AV_PROFILE_PRORES_4444,     "ap4h"},
+    { AV_PROFILE_PRORES_XQ,       "ap4x"},
+    { AV_PROFILE_UNKNOWN }
 };
 
 static const int qp_start_table[] = {  8, 3, 2, 1, 1, 1};
@@ -771,7 +771,7 @@ static int prores_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
     bytestream_put_be16(&buf, avctx->width);
     bytestream_put_be16(&buf, avctx->height);
     frame_flags = 0x82; /* 422 not interlaced */
-    if (avctx->profile >= FF_PROFILE_PRORES_4444) /* 4444 or 4444 Xq */
+    if (avctx->profile >= AV_PROFILE_PRORES_4444) /* 4444 or 4444 Xq */
         frame_flags |= 0x40; /* 444 chroma */
     if (ctx->is_interlaced) {
         if ((pict->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST) || !(pict->flags & AV_FRAME_FLAG_INTERLACED)) {
@@ -795,7 +795,7 @@ static int prores_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                                       pict->color_trc, valid_trc, 0);
     *buf++ = int_from_list_or_default(avctx, "frame colorspace",
                                       pict->colorspace, valid_colorspace, 0);
-    if (avctx->profile >= FF_PROFILE_PRORES_4444) {
+    if (avctx->profile >= AV_PROFILE_PRORES_4444) {
         if (avctx->pix_fmt == AV_PIX_FMT_YUV444P10) {
             *buf++ = 0xA0;/* src b64a and no alpha */
         } else {
@@ -871,40 +871,40 @@ static av_cold int prores_encode_init(AVCodecContext *avctx)
         return AVERROR(EINVAL);
     }
 
-    if (avctx->profile == FF_PROFILE_UNKNOWN) {
+    if (avctx->profile == AV_PROFILE_UNKNOWN) {
         if (avctx->pix_fmt == AV_PIX_FMT_YUV422P10) {
-            avctx->profile = FF_PROFILE_PRORES_STANDARD;
+            avctx->profile = AV_PROFILE_PRORES_STANDARD;
             av_log(avctx, AV_LOG_INFO,
                 "encoding with ProRes standard (apcn) profile\n");
         } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P10) {
-            avctx->profile = FF_PROFILE_PRORES_4444;
+            avctx->profile = AV_PROFILE_PRORES_4444;
             av_log(avctx, AV_LOG_INFO,
                    "encoding with ProRes 4444 (ap4h) profile\n");
         } else if (avctx->pix_fmt == AV_PIX_FMT_YUVA444P10) {
-            avctx->profile = FF_PROFILE_PRORES_4444;
+            avctx->profile = AV_PROFILE_PRORES_4444;
             av_log(avctx, AV_LOG_INFO,
                    "encoding with ProRes 4444+ (ap4h) profile\n");
         }
-    } else if (avctx->profile < FF_PROFILE_PRORES_PROXY
-            || avctx->profile > FF_PROFILE_PRORES_XQ) {
+    } else if (avctx->profile < AV_PROFILE_PRORES_PROXY
+            || avctx->profile > AV_PROFILE_PRORES_XQ) {
         av_log(
                 avctx,
                 AV_LOG_ERROR,
                 "unknown profile %d, use [0 - apco, 1 - apcs, 2 - apcn (default), 3 - apch, 4 - ap4h, 5 - ap4x]\n",
                 avctx->profile);
         return AVERROR(EINVAL);
-    } else if ((avctx->pix_fmt == AV_PIX_FMT_YUV422P10) && (avctx->profile > FF_PROFILE_PRORES_HQ)){
+    } else if ((avctx->pix_fmt == AV_PIX_FMT_YUV422P10) && (avctx->profile > AV_PROFILE_PRORES_HQ)){
         av_log(avctx, AV_LOG_ERROR,
                "encoding with ProRes 444/Xq (ap4h/ap4x) profile, need YUV444P10 input\n");
         return AVERROR(EINVAL);
     }  else if ((avctx->pix_fmt == AV_PIX_FMT_YUV444P10 || avctx->pix_fmt == AV_PIX_FMT_YUVA444P10)
-                && (avctx->profile < FF_PROFILE_PRORES_4444)){
+                && (avctx->profile < AV_PROFILE_PRORES_4444)){
         av_log(avctx, AV_LOG_ERROR,
                "encoding with ProRes Proxy/LT/422/422 HQ (apco, apcs, apcn, ap4h) profile, need YUV422P10 input\n");
         return AVERROR(EINVAL);
     }
 
-    if (avctx->profile < FF_PROFILE_PRORES_4444) { /* 422 versions */
+    if (avctx->profile < AV_PROFILE_PRORES_4444) { /* 422 versions */
         ctx->is_422 = 1;
         if ((avctx->height & 0xf) || (avctx->width & 0xf)) {
             ctx->fill_y = av_malloc(4 * (DEFAULT_SLICE_MB_WIDTH << 8));
diff --git a/libavcodec/sbcenc.c b/libavcodec/sbcenc.c
index 9d6e0b9f54..6e1dd88c72 100644
--- a/libavcodec/sbcenc.c
+++ b/libavcodec/sbcenc.c
@@ -199,7 +199,7 @@ static int sbc_encode_init(AVCodecContext *avctx)
     SBCEncContext *sbc = avctx->priv_data;
     struct sbc_frame *frame = &sbc->frame;
 
-    if (avctx->profile == FF_PROFILE_SBC_MSBC)
+    if (avctx->profile == AV_PROFILE_SBC_MSBC)
         sbc->msbc = 1;
 
     if (sbc->msbc) {
@@ -333,7 +333,7 @@ static const AVOption options[] = {
       OFFSET(max_delay), AV_OPT_TYPE_DURATION, {.i64 = 13000}, 1000,13000, AE },
     { "msbc",      "use mSBC mode (wideband speech mono SBC)",
       OFFSET(msbc),      AV_OPT_TYPE_BOOL,     {.i64 = 0},        0,    1, AE },
-    FF_AVCTX_PROFILE_OPTION("msbc", NULL, AUDIO, FF_PROFILE_SBC_MSBC)
+    FF_AVCTX_PROFILE_OPTION("msbc", NULL, AUDIO, AV_PROFILE_SBC_MSBC)
     { NULL },
 };
 
diff --git a/libavcodec/utils.c b/libavcodec/utils.c
index d54e050848..3cb3828228 100644
--- a/libavcodec/utils.c
+++ b/libavcodec/utils.c
@@ -434,10 +434,10 @@ const char *avcodec_get_name(enum AVCodecID id)
 const char *av_get_profile_name(const AVCodec *codec, int profile)
 {
     const AVProfile *p;
-    if (profile == FF_PROFILE_UNKNOWN || !codec->profiles)
+    if (profile == AV_PROFILE_UNKNOWN || !codec->profiles)
         return NULL;
 
-    for (p = codec->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
+    for (p = codec->profiles; p->profile != AV_PROFILE_UNKNOWN; p++)
         if (p->profile == profile)
             return p->name;
 
@@ -449,10 +449,10 @@ const char *avcodec_profile_name(enum AVCodecID codec_id, int profile)
     const AVCodecDescriptor *desc = avcodec_descriptor_get(codec_id);
     const AVProfile *p;
 
-    if (profile == FF_PROFILE_UNKNOWN || !desc || !desc->profiles)
+    if (profile == AV_PROFILE_UNKNOWN || !desc || !desc->profiles)
         return NULL;
 
-    for (p = desc->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
+    for (p = desc->profiles; p->profile != AV_PROFILE_UNKNOWN; p++)
         if (p->profile == profile)
             return p->name;
 
diff --git a/libavcodec/v4l2_m2m_enc.c b/libavcodec/v4l2_m2m_enc.c
index 9a0837ecf3..e08db5d5d3 100644
--- a/libavcodec/v4l2_m2m_enc.c
+++ b/libavcodec/v4l2_m2m_enc.c
@@ -103,17 +103,17 @@ static inline unsigned int v4l2_h264_profile_from_ff(int p)
         unsigned int ffmpeg_val;
         unsigned int v4l2_val;
     } profile[] = {
-        { FF_PROFILE_H264_CONSTRAINED_BASELINE, MPEG_VIDEO(H264_PROFILE_CONSTRAINED_BASELINE) },
-        { FF_PROFILE_H264_HIGH_444_PREDICTIVE, MPEG_VIDEO(H264_PROFILE_HIGH_444_PREDICTIVE) },
-        { FF_PROFILE_H264_HIGH_422_INTRA, MPEG_VIDEO(H264_PROFILE_HIGH_422_INTRA) },
-        { FF_PROFILE_H264_HIGH_444_INTRA, MPEG_VIDEO(H264_PROFILE_HIGH_444_INTRA) },
-        { FF_PROFILE_H264_HIGH_10_INTRA, MPEG_VIDEO(H264_PROFILE_HIGH_10_INTRA) },
-        { FF_PROFILE_H264_HIGH_422, MPEG_VIDEO(H264_PROFILE_HIGH_422) },
-        { FF_PROFILE_H264_BASELINE, MPEG_VIDEO(H264_PROFILE_BASELINE) },
-        { FF_PROFILE_H264_EXTENDED, MPEG_VIDEO(H264_PROFILE_EXTENDED) },
-        { FF_PROFILE_H264_HIGH_10, MPEG_VIDEO(H264_PROFILE_HIGH_10) },
-        { FF_PROFILE_H264_MAIN, MPEG_VIDEO(H264_PROFILE_MAIN) },
-        { FF_PROFILE_H264_HIGH, MPEG_VIDEO(H264_PROFILE_HIGH) },
+        { AV_PROFILE_H264_CONSTRAINED_BASELINE, MPEG_VIDEO(H264_PROFILE_CONSTRAINED_BASELINE) },
+        { AV_PROFILE_H264_HIGH_444_PREDICTIVE, MPEG_VIDEO(H264_PROFILE_HIGH_444_PREDICTIVE) },
+        { AV_PROFILE_H264_HIGH_422_INTRA, MPEG_VIDEO(H264_PROFILE_HIGH_422_INTRA) },
+        { AV_PROFILE_H264_HIGH_444_INTRA, MPEG_VIDEO(H264_PROFILE_HIGH_444_INTRA) },
+        { AV_PROFILE_H264_HIGH_10_INTRA, MPEG_VIDEO(H264_PROFILE_HIGH_10_INTRA) },
+        { AV_PROFILE_H264_HIGH_422, MPEG_VIDEO(H264_PROFILE_HIGH_422) },
+        { AV_PROFILE_H264_BASELINE, MPEG_VIDEO(H264_PROFILE_BASELINE) },
+        { AV_PROFILE_H264_EXTENDED, MPEG_VIDEO(H264_PROFILE_EXTENDED) },
+        { AV_PROFILE_H264_HIGH_10, MPEG_VIDEO(H264_PROFILE_HIGH_10) },
+        { AV_PROFILE_H264_MAIN, MPEG_VIDEO(H264_PROFILE_MAIN) },
+        { AV_PROFILE_H264_HIGH, MPEG_VIDEO(H264_PROFILE_HIGH) },
     };
     int i;
 
@@ -130,11 +130,11 @@ static inline int v4l2_mpeg4_profile_from_ff(int p)
         unsigned int ffmpeg_val;
         unsigned int v4l2_val;
     } profile[] = {
-        { FF_PROFILE_MPEG4_ADVANCED_CODING, MPEG_VIDEO(MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY) },
-        { FF_PROFILE_MPEG4_ADVANCED_SIMPLE, MPEG_VIDEO(MPEG4_PROFILE_ADVANCED_SIMPLE) },
-        { FF_PROFILE_MPEG4_SIMPLE_SCALABLE, MPEG_VIDEO(MPEG4_PROFILE_SIMPLE_SCALABLE) },
-        { FF_PROFILE_MPEG4_SIMPLE, MPEG_VIDEO(MPEG4_PROFILE_SIMPLE) },
-        { FF_PROFILE_MPEG4_CORE, MPEG_VIDEO(MPEG4_PROFILE_CORE) },
+        { AV_PROFILE_MPEG4_ADVANCED_CODING, MPEG_VIDEO(MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY) },
+        { AV_PROFILE_MPEG4_ADVANCED_SIMPLE, MPEG_VIDEO(MPEG4_PROFILE_ADVANCED_SIMPLE) },
+        { AV_PROFILE_MPEG4_SIMPLE_SCALABLE, MPEG_VIDEO(MPEG4_PROFILE_SIMPLE_SCALABLE) },
+        { AV_PROFILE_MPEG4_SIMPLE, MPEG_VIDEO(MPEG4_PROFILE_SIMPLE) },
+        { AV_PROFILE_MPEG4_CORE, MPEG_VIDEO(MPEG4_PROFILE_CORE) },
     };
     int i;
 
@@ -206,7 +206,7 @@ static int v4l2_prepare_encoder(V4L2m2mContext *s)
 
     switch (avctx->codec_id) {
     case AV_CODEC_ID_H264:
-        if (avctx->profile != FF_PROFILE_UNKNOWN) {
+        if (avctx->profile != AV_PROFILE_UNKNOWN) {
             val = v4l2_h264_profile_from_ff(avctx->profile);
             if (val < 0)
                 av_log(avctx, AV_LOG_WARNING, "h264 profile not found\n");
@@ -219,7 +219,7 @@ static int v4l2_prepare_encoder(V4L2m2mContext *s)
         qmax = 51;
         break;
     case AV_CODEC_ID_MPEG4:
-        if (avctx->profile != FF_PROFILE_UNKNOWN) {
+        if (avctx->profile != AV_PROFILE_UNKNOWN) {
             val = v4l2_mpeg4_profile_from_ff(avctx->profile);
             if (val < 0)
                 av_log(avctx, AV_LOG_WARNING, "mpeg4 profile not found\n");
diff --git a/libavcodec/vaapi_decode.c b/libavcodec/vaapi_decode.c
index dd55cbd6f1..10b4284db0 100644
--- a/libavcodec/vaapi_decode.c
+++ b/libavcodec/vaapi_decode.c
@@ -390,7 +390,7 @@ static const struct {
     VAProfile va_profile;
     VAProfile (*profile_parser)(AVCodecContext *avctx);
 } vaapi_profile_map[] = {
-#define MAP(c, p, v, ...) { AV_CODEC_ID_ ## c, FF_PROFILE_ ## p, VAProfile ## v, __VA_ARGS__ }
+#define MAP(c, p, v, ...) { AV_CODEC_ID_ ## c, AV_PROFILE_ ## p, VAProfile ## v, __VA_ARGS__ }
     MAP(MPEG2VIDEO,  MPEG2_SIMPLE,    MPEG2Simple ),
     MAP(MPEG2VIDEO,  MPEG2_MAIN,      MPEG2Main   ),
     MAP(H263,        UNKNOWN,         H263Baseline),
@@ -497,7 +497,7 @@ static int vaapi_decode_make_config(AVCodecContext *avctx,
         if (avctx->codec_id != vaapi_profile_map[i].codec_id)
             continue;
         if (avctx->profile == vaapi_profile_map[i].codec_profile ||
-            vaapi_profile_map[i].codec_profile == FF_PROFILE_UNKNOWN)
+            vaapi_profile_map[i].codec_profile == AV_PROFILE_UNKNOWN)
             profile_match = 1;
 
         va_profile = vaapi_profile_map[i].profile_parser ?
diff --git a/libavcodec/vaapi_encode.c b/libavcodec/vaapi_encode.c
index bfca315a7a..0316fe5c18 100644
--- a/libavcodec/vaapi_encode.c
+++ b/libavcodec/vaapi_encode.c
@@ -1414,7 +1414,7 @@ static av_cold int vaapi_encode_profile_entrypoint(AVCodecContext *avctx)
 
     av_assert0(ctx->codec->profiles);
     for (i = 0; (ctx->codec->profiles[i].av_profile !=
-                 FF_PROFILE_UNKNOWN); i++) {
+                 AV_PROFILE_UNKNOWN); i++) {
         profile = &ctx->codec->profiles[i];
         if (depth               != profile->depth ||
             desc->nb_components != profile->nb_components)
@@ -1424,7 +1424,7 @@ static av_cold int vaapi_encode_profile_entrypoint(AVCodecContext *avctx)
              desc->log2_chroma_h != profile->log2_chroma_h))
             continue;
         if (avctx->profile != profile->av_profile &&
-            avctx->profile != FF_PROFILE_UNKNOWN)
+            avctx->profile != AV_PROFILE_UNKNOWN)
             continue;
 
 #if VA_CHECK_VERSION(1, 0, 0)
diff --git a/libavcodec/vaapi_encode.h b/libavcodec/vaapi_encode.h
index a1e639f56b..bd25cd5c95 100644
--- a/libavcodec/vaapi_encode.h
+++ b/libavcodec/vaapi_encode.h
@@ -134,7 +134,7 @@ typedef struct VAAPIEncodePicture {
 } VAAPIEncodePicture;
 
 typedef struct VAAPIEncodeProfile {
-    // lavc profile value (FF_PROFILE_*).
+    // lavc profile value (AV_PROFILE_*).
     int       av_profile;
     // Supported bit depth.
     int       depth;
@@ -384,7 +384,7 @@ enum {
 
 typedef struct VAAPIEncodeType {
     // List of supported profiles and corresponding VAAPI profiles.
-    // (Must end with FF_PROFILE_UNKNOWN.)
+    // (Must end with AV_PROFILE_UNKNOWN.)
     const VAAPIEncodeProfile *profiles;
 
     // Codec feature flags.
diff --git a/libavcodec/vaapi_encode_h264.c b/libavcodec/vaapi_encode_h264.c
index 9ad017d540..09e1300113 100644
--- a/libavcodec/vaapi_encode_h264.c
+++ b/libavcodec/vaapi_encode_h264.c
@@ -322,15 +322,15 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx)
 
     sps->profile_idc = avctx->profile & 0xff;
 
-    if (avctx->profile == FF_PROFILE_H264_CONSTRAINED_BASELINE ||
-        avctx->profile == FF_PROFILE_H264_MAIN)
+    if (avctx->profile == AV_PROFILE_H264_CONSTRAINED_BASELINE ||
+        avctx->profile == AV_PROFILE_H264_MAIN)
         sps->constraint_set1_flag = 1;
 
-    if (avctx->profile == FF_PROFILE_H264_HIGH || avctx->profile == FF_PROFILE_H264_HIGH_10)
+    if (avctx->profile == AV_PROFILE_H264_HIGH || avctx->profile == AV_PROFILE_H264_HIGH_10)
         sps->constraint_set3_flag = ctx->gop_size == 1;
 
-    if (avctx->profile == FF_PROFILE_H264_MAIN ||
-        avctx->profile == FF_PROFILE_H264_HIGH || avctx->profile == FF_PROFILE_H264_HIGH_10) {
+    if (avctx->profile == AV_PROFILE_H264_MAIN ||
+        avctx->profile == AV_PROFILE_H264_HIGH || avctx->profile == AV_PROFILE_H264_HIGH_10) {
         sps->constraint_set4_flag = 1;
         sps->constraint_set5_flag = ctx->b_per_p == 0;
     }
@@ -340,7 +340,7 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx)
     else
         priv->dpb_frames = 1 + ctx->max_b_depth;
 
-    if (avctx->level != FF_LEVEL_UNKNOWN) {
+    if (avctx->level != AV_LEVEL_UNKNOWN) {
         sps->level_idc = avctx->level;
     } else {
         const H264LevelDescriptor *level;
@@ -512,9 +512,9 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx)
     pps->seq_parameter_set_id = 0;
 
     pps->entropy_coding_mode_flag =
-        !(sps->profile_idc == FF_PROFILE_H264_BASELINE ||
-          sps->profile_idc == FF_PROFILE_H264_EXTENDED ||
-          sps->profile_idc == FF_PROFILE_H264_CAVLC_444);
+        !(sps->profile_idc == AV_PROFILE_H264_BASELINE ||
+          sps->profile_idc == AV_PROFILE_H264_EXTENDED ||
+          sps->profile_idc == AV_PROFILE_H264_CAVLC_444);
     if (!priv->coder && pps->entropy_coding_mode_flag)
         pps->entropy_coding_mode_flag = 0;
 
@@ -523,9 +523,9 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx)
 
     pps->pic_init_qp_minus26 = priv->fixed_qp_idr - 26;
 
-    if (sps->profile_idc == FF_PROFILE_H264_BASELINE ||
-        sps->profile_idc == FF_PROFILE_H264_EXTENDED ||
-        sps->profile_idc == FF_PROFILE_H264_MAIN) {
+    if (sps->profile_idc == AV_PROFILE_H264_BASELINE ||
+        sps->profile_idc == AV_PROFILE_H264_EXTENDED ||
+        sps->profile_idc == AV_PROFILE_H264_MAIN) {
         pps->more_rbsp_data = 0;
     } else {
         pps->more_rbsp_data = 1;
@@ -1159,13 +1159,13 @@ static av_cold int vaapi_encode_h264_configure(AVCodecContext *avctx)
 
 static const VAAPIEncodeProfile vaapi_encode_h264_profiles[] = {
 #if VA_CHECK_VERSION(1, 18, 0)
-    { FF_PROFILE_H264_HIGH_10, 10, 3, 1, 1, VAProfileH264High10 },
+    { AV_PROFILE_H264_HIGH_10, 10, 3, 1, 1, VAProfileH264High10 },
 #endif
-    { FF_PROFILE_H264_HIGH, 8, 3, 1, 1, VAProfileH264High },
-    { FF_PROFILE_H264_MAIN, 8, 3, 1, 1, VAProfileH264Main },
-    { FF_PROFILE_H264_CONSTRAINED_BASELINE,
+    { AV_PROFILE_H264_HIGH, 8, 3, 1, 1, VAProfileH264High },
+    { AV_PROFILE_H264_MAIN, 8, 3, 1, 1, VAProfileH264Main },
+    { AV_PROFILE_H264_CONSTRAINED_BASELINE,
                             8, 3, 1, 1, VAProfileH264ConstrainedBaseline },
-    { FF_PROFILE_UNKNOWN }
+    { AV_PROFILE_UNKNOWN }
 };
 
 static const VAAPIEncodeType vaapi_encode_type_h264 = {
@@ -1207,40 +1207,40 @@ static av_cold int vaapi_encode_h264_init(AVCodecContext *avctx)
 
     ctx->codec = &vaapi_encode_type_h264;
 
-    if (avctx->profile == FF_PROFILE_UNKNOWN)
+    if (avctx->profile == AV_PROFILE_UNKNOWN)
         avctx->profile = priv->profile;
-    if (avctx->level == FF_LEVEL_UNKNOWN)
+    if (avctx->level == AV_LEVEL_UNKNOWN)
         avctx->level = priv->level;
     if (avctx->compression_level == FF_COMPRESSION_DEFAULT)
         avctx->compression_level = priv->quality;
 
     // Reject unsupported profiles.
     switch (avctx->profile) {
-    case FF_PROFILE_H264_BASELINE:
+    case AV_PROFILE_H264_BASELINE:
         av_log(avctx, AV_LOG_WARNING, "H.264 baseline profile is not "
                "supported, using constrained baseline profile instead.\n");
-        avctx->profile = FF_PROFILE_H264_CONSTRAINED_BASELINE;
+        avctx->profile = AV_PROFILE_H264_CONSTRAINED_BASELINE;
         break;
-    case FF_PROFILE_H264_EXTENDED:
+    case AV_PROFILE_H264_EXTENDED:
         av_log(avctx, AV_LOG_ERROR, "H.264 extended profile "
                "is not supported.\n");
         return AVERROR_PATCHWELCOME;
-    case FF_PROFILE_H264_HIGH_10_INTRA:
+    case AV_PROFILE_H264_HIGH_10_INTRA:
         av_log(avctx, AV_LOG_ERROR, "H.264 high 10 intra profile "
                "is not supported.\n");
         return AVERROR_PATCHWELCOME;
-    case FF_PROFILE_H264_HIGH_422:
-    case FF_PROFILE_H264_HIGH_422_INTRA:
-    case FF_PROFILE_H264_HIGH_444:
-    case FF_PROFILE_H264_HIGH_444_PREDICTIVE:
-    case FF_PROFILE_H264_HIGH_444_INTRA:
-    case FF_PROFILE_H264_CAVLC_444:
+    case AV_PROFILE_H264_HIGH_422:
+    case AV_PROFILE_H264_HIGH_422_INTRA:
+    case AV_PROFILE_H264_HIGH_444:
+    case AV_PROFILE_H264_HIGH_444_PREDICTIVE:
+    case AV_PROFILE_H264_HIGH_444_INTRA:
+    case AV_PROFILE_H264_CAVLC_444:
         av_log(avctx, AV_LOG_ERROR, "H.264 non-4:2:0 profiles "
                "are not supported.\n");
         return AVERROR_PATCHWELCOME;
     }
 
-    if (avctx->level != FF_LEVEL_UNKNOWN && avctx->level & ~0xff) {
+    if (avctx->level != AV_LEVEL_UNKNOWN && avctx->level & ~0xff) {
         av_log(avctx, AV_LOG_ERROR, "Invalid level %d: must fit "
                "in 8-bit unsigned integer.\n", avctx->level);
         return AVERROR(EINVAL);
@@ -1313,19 +1313,19 @@ static const AVOption vaapi_encode_h264_options[] = {
 
     { "profile", "Set profile (profile_idc and constraint_set*_flag)",
       OFFSET(profile), AV_OPT_TYPE_INT,
-      { .i64 = FF_PROFILE_UNKNOWN }, FF_PROFILE_UNKNOWN, 0xffff, FLAGS, "profile" },
+      { .i64 = AV_PROFILE_UNKNOWN }, AV_PROFILE_UNKNOWN, 0xffff, FLAGS, "profile" },
 
 #define PROFILE(name, value)  name, NULL, 0, AV_OPT_TYPE_CONST, \
       { .i64 = value }, 0, 0, FLAGS, "profile"
-    { PROFILE("constrained_baseline", FF_PROFILE_H264_CONSTRAINED_BASELINE) },
-    { PROFILE("main",                 FF_PROFILE_H264_MAIN) },
-    { PROFILE("high",                 FF_PROFILE_H264_HIGH) },
-    { PROFILE("high10",               FF_PROFILE_H264_HIGH_10) },
+    { PROFILE("constrained_baseline", AV_PROFILE_H264_CONSTRAINED_BASELINE) },
+    { PROFILE("main",                 AV_PROFILE_H264_MAIN) },
+    { PROFILE("high",                 AV_PROFILE_H264_HIGH) },
+    { PROFILE("high10",               AV_PROFILE_H264_HIGH_10) },
 #undef PROFILE
 
     { "level", "Set level (level_idc)",
       OFFSET(level), AV_OPT_TYPE_INT,
-      { .i64 = FF_LEVEL_UNKNOWN }, FF_LEVEL_UNKNOWN, 0xff, FLAGS, "level" },
+      { .i64 = AV_LEVEL_UNKNOWN }, AV_LEVEL_UNKNOWN, 0xff, FLAGS, "level" },
 
 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
       { .i64 = value }, 0, 0, FLAGS, "level"
diff --git a/libavcodec/vaapi_encode_h265.c b/libavcodec/vaapi_encode_h265.c
index aa7e532f9a..efa59aecf5 100644
--- a/libavcodec/vaapi_encode_h265.c
+++ b/libavcodec/vaapi_encode_h265.c
@@ -346,7 +346,7 @@ static int vaapi_encode_h265_init_sequence_params(AVCodecContext *avctx)
 
     ptl->general_lower_bit_rate_constraint_flag = 1;
 
-    if (avctx->level != FF_LEVEL_UNKNOWN) {
+    if (avctx->level != AV_LEVEL_UNKNOWN) {
         ptl->general_level_idc = avctx->level;
     } else {
         const H265LevelDescriptor *level;
@@ -1290,22 +1290,22 @@ static av_cold int vaapi_encode_h265_configure(AVCodecContext *avctx)
 }
 
 static const VAAPIEncodeProfile vaapi_encode_h265_profiles[] = {
-    { FF_PROFILE_HEVC_MAIN,     8, 3, 1, 1, VAProfileHEVCMain       },
-    { FF_PROFILE_HEVC_REXT,     8, 3, 1, 1, VAProfileHEVCMain       },
+    { AV_PROFILE_HEVC_MAIN,     8, 3, 1, 1, VAProfileHEVCMain       },
+    { AV_PROFILE_HEVC_REXT,     8, 3, 1, 1, VAProfileHEVCMain       },
 #if VA_CHECK_VERSION(0, 37, 0)
-    { FF_PROFILE_HEVC_MAIN_10, 10, 3, 1, 1, VAProfileHEVCMain10     },
-    { FF_PROFILE_HEVC_REXT,    10, 3, 1, 1, VAProfileHEVCMain10     },
+    { AV_PROFILE_HEVC_MAIN_10, 10, 3, 1, 1, VAProfileHEVCMain10     },
+    { AV_PROFILE_HEVC_REXT,    10, 3, 1, 1, VAProfileHEVCMain10     },
 #endif
 #if VA_CHECK_VERSION(1, 2, 0)
-    { FF_PROFILE_HEVC_REXT,    12, 3, 1, 1, VAProfileHEVCMain12 },
-    { FF_PROFILE_HEVC_REXT,     8, 3, 1, 0, VAProfileHEVCMain422_10 },
-    { FF_PROFILE_HEVC_REXT,    10, 3, 1, 0, VAProfileHEVCMain422_10 },
-    { FF_PROFILE_HEVC_REXT,    12, 3, 1, 0, VAProfileHEVCMain422_12 },
-    { FF_PROFILE_HEVC_REXT,     8, 3, 0, 0, VAProfileHEVCMain444 },
-    { FF_PROFILE_HEVC_REXT,    10, 3, 0, 0, VAProfileHEVCMain444_10 },
-    { FF_PROFILE_HEVC_REXT,    12, 3, 0, 0, VAProfileHEVCMain444_12 },
+    { AV_PROFILE_HEVC_REXT,    12, 3, 1, 1, VAProfileHEVCMain12 },
+    { AV_PROFILE_HEVC_REXT,     8, 3, 1, 0, VAProfileHEVCMain422_10 },
+    { AV_PROFILE_HEVC_REXT,    10, 3, 1, 0, VAProfileHEVCMain422_10 },
+    { AV_PROFILE_HEVC_REXT,    12, 3, 1, 0, VAProfileHEVCMain422_12 },
+    { AV_PROFILE_HEVC_REXT,     8, 3, 0, 0, VAProfileHEVCMain444 },
+    { AV_PROFILE_HEVC_REXT,    10, 3, 0, 0, VAProfileHEVCMain444_10 },
+    { AV_PROFILE_HEVC_REXT,    12, 3, 0, 0, VAProfileHEVCMain444_12 },
 #endif
-    { FF_PROFILE_UNKNOWN }
+    { AV_PROFILE_UNKNOWN }
 };
 
 static const VAAPIEncodeType vaapi_encode_type_h265 = {
@@ -1348,12 +1348,12 @@ static av_cold int vaapi_encode_h265_init(AVCodecContext *avctx)
 
     ctx->codec = &vaapi_encode_type_h265;
 
-    if (avctx->profile == FF_PROFILE_UNKNOWN)
+    if (avctx->profile == AV_PROFILE_UNKNOWN)
         avctx->profile = priv->profile;
-    if (avctx->level == FF_LEVEL_UNKNOWN)
+    if (avctx->level == AV_LEVEL_UNKNOWN)
         avctx->level = priv->level;
 
-    if (avctx->level != FF_LEVEL_UNKNOWN && avctx->level & ~0xff) {
+    if (avctx->level != AV_LEVEL_UNKNOWN && avctx->level & ~0xff) {
         av_log(avctx, AV_LOG_ERROR, "Invalid level %d: must fit "
                "in 8-bit unsigned integer.\n", avctx->level);
         return AVERROR(EINVAL);
@@ -1395,13 +1395,13 @@ static const AVOption vaapi_encode_h265_options[] = {
 
     { "profile", "Set profile (general_profile_idc)",
       OFFSET(profile), AV_OPT_TYPE_INT,
-      { .i64 = FF_PROFILE_UNKNOWN }, FF_PROFILE_UNKNOWN, 0xff, FLAGS, "profile" },
+      { .i64 = AV_PROFILE_UNKNOWN }, AV_PROFILE_UNKNOWN, 0xff, FLAGS, "profile" },
 
 #define PROFILE(name, value)  name, NULL, 0, AV_OPT_TYPE_CONST, \
       { .i64 = value }, 0, 0, FLAGS, "profile"
-    { PROFILE("main",               FF_PROFILE_HEVC_MAIN) },
-    { PROFILE("main10",             FF_PROFILE_HEVC_MAIN_10) },
-    { PROFILE("rext",               FF_PROFILE_HEVC_REXT) },
+    { PROFILE("main",               AV_PROFILE_HEVC_MAIN) },
+    { PROFILE("main10",             AV_PROFILE_HEVC_MAIN_10) },
+    { PROFILE("rext",               AV_PROFILE_HEVC_REXT) },
 #undef PROFILE
 
     { "tier", "Set tier (general_tier_flag)",
@@ -1414,7 +1414,7 @@ static const AVOption vaapi_encode_h265_options[] = {
 
     { "level", "Set level (general_level_idc)",
       OFFSET(level), AV_OPT_TYPE_INT,
-      { .i64 = FF_LEVEL_UNKNOWN }, FF_LEVEL_UNKNOWN, 0xff, FLAGS, "level" },
+      { .i64 = AV_LEVEL_UNKNOWN }, AV_LEVEL_UNKNOWN, 0xff, FLAGS, "level" },
 
 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
       { .i64 = value }, 0, 0, FLAGS, "level"
diff --git a/libavcodec/vaapi_encode_mjpeg.c b/libavcodec/vaapi_encode_mjpeg.c
index cb7588b94b..c17747e3a9 100644
--- a/libavcodec/vaapi_encode_mjpeg.c
+++ b/libavcodec/vaapi_encode_mjpeg.c
@@ -480,15 +480,15 @@ static av_cold int vaapi_encode_mjpeg_configure(AVCodecContext *avctx)
 }
 
 static const VAAPIEncodeProfile vaapi_encode_mjpeg_profiles[] = {
-    { FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT,
+    { AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT,
             8, 1, 0, 0, VAProfileJPEGBaseline },
-    { FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT,
+    { AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT,
             8, 3, 1, 1, VAProfileJPEGBaseline },
-    { FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT,
+    { AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT,
             8, 3, 1, 0, VAProfileJPEGBaseline },
-    { FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT,
+    { AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT,
             8, 3, 0, 0, VAProfileJPEGBaseline },
-    { FF_PROFILE_UNKNOWN }
+    { AV_PROFILE_UNKNOWN }
 };
 
 static const VAAPIEncodeType vaapi_encode_type_mjpeg = {
diff --git a/libavcodec/vaapi_encode_mpeg2.c b/libavcodec/vaapi_encode_mpeg2.c
index 9261d19a83..2edb0c3586 100644
--- a/libavcodec/vaapi_encode_mpeg2.c
+++ b/libavcodec/vaapi_encode_mpeg2.c
@@ -558,9 +558,9 @@ static av_cold int vaapi_encode_mpeg2_configure(AVCodecContext *avctx)
 }
 
 static const VAAPIEncodeProfile vaapi_encode_mpeg2_profiles[] = {
-    { FF_PROFILE_MPEG2_MAIN,   8, 3, 1, 1, VAProfileMPEG2Main   },
-    { FF_PROFILE_MPEG2_SIMPLE, 8, 3, 1, 1, VAProfileMPEG2Simple },
-    { FF_PROFILE_UNKNOWN }
+    { AV_PROFILE_MPEG2_MAIN,   8, 3, 1, 1, VAProfileMPEG2Main   },
+    { AV_PROFILE_MPEG2_SIMPLE, 8, 3, 1, 1, VAProfileMPEG2Simple },
+    { AV_PROFILE_UNKNOWN }
 };
 
 static const VAAPIEncodeType vaapi_encode_type_mpeg2 = {
@@ -595,9 +595,9 @@ static av_cold int vaapi_encode_mpeg2_init(AVCodecContext *avctx)
 
     ctx->codec = &vaapi_encode_type_mpeg2;
 
-    if (avctx->profile == FF_PROFILE_UNKNOWN)
+    if (avctx->profile == AV_PROFILE_UNKNOWN)
         avctx->profile = priv->profile;
-    if (avctx->level == FF_LEVEL_UNKNOWN)
+    if (avctx->level == AV_LEVEL_UNKNOWN)
         avctx->level = priv->level;
 
     // Reject unknown levels (these are required to set f_code for
@@ -644,12 +644,12 @@ static const AVOption vaapi_encode_mpeg2_options[] = {
 
     { "profile", "Set profile (in profile_and_level_indication)",
       OFFSET(profile), AV_OPT_TYPE_INT,
-      { .i64 = FF_PROFILE_UNKNOWN }, FF_PROFILE_UNKNOWN, 7, FLAGS, "profile" },
+      { .i64 = AV_PROFILE_UNKNOWN }, AV_PROFILE_UNKNOWN, 7, FLAGS, "profile" },
 
 #define PROFILE(name, value)  name, NULL, 0, AV_OPT_TYPE_CONST, \
       { .i64 = value }, 0, 0, FLAGS, "profile"
-    { PROFILE("simple", FF_PROFILE_MPEG2_SIMPLE) },
-    { PROFILE("main",   FF_PROFILE_MPEG2_MAIN)   },
+    { PROFILE("simple", AV_PROFILE_MPEG2_SIMPLE) },
+    { PROFILE("main",   AV_PROFILE_MPEG2_MAIN)   },
 #undef PROFILE
 
     { "level", "Set level (in profile_and_level_indication)",
diff --git a/libavcodec/vaapi_encode_vp8.c b/libavcodec/vaapi_encode_vp8.c
index ae6a8d313c..ea8abb2418 100644
--- a/libavcodec/vaapi_encode_vp8.c
+++ b/libavcodec/vaapi_encode_vp8.c
@@ -180,7 +180,7 @@ static av_cold int vaapi_encode_vp8_configure(AVCodecContext *avctx)
 
 static const VAAPIEncodeProfile vaapi_encode_vp8_profiles[] = {
     { 0 /* VP8 has no profiles */, 8, 3, 1, 1, VAProfileVP8Version0_3 },
-    { FF_PROFILE_UNKNOWN }
+    { AV_PROFILE_UNKNOWN }
 };
 
 static const VAAPIEncodeType vaapi_encode_type_vp8 = {
diff --git a/libavcodec/vaapi_encode_vp9.c b/libavcodec/vaapi_encode_vp9.c
index af1353cea8..87429881f1 100644
--- a/libavcodec/vaapi_encode_vp9.c
+++ b/libavcodec/vaapi_encode_vp9.c
@@ -227,11 +227,11 @@ static av_cold int vaapi_encode_vp9_configure(AVCodecContext *avctx)
 }
 
 static const VAAPIEncodeProfile vaapi_encode_vp9_profiles[] = {
-    { FF_PROFILE_VP9_0,  8, 3, 1, 1, VAProfileVP9Profile0 },
-    { FF_PROFILE_VP9_1,  8, 3, 0, 0, VAProfileVP9Profile1 },
-    { FF_PROFILE_VP9_2, 10, 3, 1, 1, VAProfileVP9Profile2 },
-    { FF_PROFILE_VP9_3, 10, 3, 0, 0, VAProfileVP9Profile3 },
-    { FF_PROFILE_UNKNOWN }
+    { AV_PROFILE_VP9_0,  8, 3, 1, 1, VAProfileVP9Profile0 },
+    { AV_PROFILE_VP9_1,  8, 3, 0, 0, VAProfileVP9Profile1 },
+    { AV_PROFILE_VP9_2, 10, 3, 1, 1, VAProfileVP9Profile2 },
+    { AV_PROFILE_VP9_3, 10, 3, 0, 0, VAProfileVP9Profile3 },
+    { AV_PROFILE_UNKNOWN }
 };
 
 static const VAAPIEncodeType vaapi_encode_type_vp9 = {
diff --git a/libavcodec/vaapi_hevc.c b/libavcodec/vaapi_hevc.c
index d464fda18c..3bdd2dd1b8 100644
--- a/libavcodec/vaapi_hevc.c
+++ b/libavcodec/vaapi_hevc.c
@@ -227,8 +227,8 @@ static int vaapi_hevc_start_frame(AVCodecContext          *avctx,
     }
 
 #if VA_CHECK_VERSION(1, 2, 0)
-    if (avctx->profile == FF_PROFILE_HEVC_REXT ||
-        avctx->profile == FF_PROFILE_HEVC_SCC) {
+    if (avctx->profile == AV_PROFILE_HEVC_REXT ||
+        avctx->profile == AV_PROFILE_HEVC_SCC) {
         pic->pic_param.rext = (VAPictureParameterBufferHEVCRext) {
             .range_extension_pic_fields.bits  = {
                 .transform_skip_rotation_enabled_flag       = sps->transform_skip_rotation_enabled_flag,
@@ -262,7 +262,7 @@ static int vaapi_hevc_start_frame(AVCodecContext          *avctx,
                        sps->sps_num_palette_predictor_initializers :
                        0);
 
-    if (avctx->profile == FF_PROFILE_HEVC_SCC) {
+    if (avctx->profile == AV_PROFILE_HEVC_SCC) {
         pic->pic_param.scc = (VAPictureParameterBufferHEVCScc) {
             .screen_content_pic_fields.bits = {
                 .pps_curr_pic_ref_enabled_flag              = pps->pps_curr_pic_ref_enabled_flag,
@@ -294,7 +294,7 @@ static int vaapi_hevc_start_frame(AVCodecContext          *avctx,
     }
 
 #endif
-    pic_param_size = avctx->profile >= FF_PROFILE_HEVC_REXT ?
+    pic_param_size = avctx->profile >= AV_PROFILE_HEVC_REXT ?
                             sizeof(pic->pic_param) : sizeof(VAPictureParameterBufferHEVC);
 
     err = ff_vaapi_decode_make_param_buffer(avctx, &pic->pic,
@@ -347,7 +347,7 @@ static int vaapi_hevc_end_frame(AVCodecContext *avctx)
     VASliceParameterBufferHEVC *last_slice_param = (VASliceParameterBufferHEVC *)&pic->last_slice_param;
     int ret;
 
-    int slice_param_size = avctx->profile >= FF_PROFILE_HEVC_REXT ?
+    int slice_param_size = avctx->profile >= AV_PROFILE_HEVC_REXT ?
                             sizeof(pic->last_slice_param) : sizeof(VASliceParameterBufferHEVC);
 
     if (pic->last_size) {
@@ -377,10 +377,10 @@ static void fill_pred_weight_table(AVCodecContext *avctx,
 {
     int i;
 #if VA_CHECK_VERSION(1, 2, 0)
-    int is_rext = avctx->profile >= FF_PROFILE_HEVC_REXT;
+    int is_rext = avctx->profile >= AV_PROFILE_HEVC_REXT;
 #else
     int is_rext = 0;
-    if (avctx->profile >= FF_PROFILE_HEVC_REXT)
+    if (avctx->profile >= AV_PROFILE_HEVC_REXT)
         av_log(avctx, AV_LOG_WARNING, "Please consider to update to VAAPI 1.2.0 "
                "or above, which can support REXT related setting correctly.\n");
 #endif
@@ -461,7 +461,7 @@ static int vaapi_hevc_decode_slice(AVCodecContext *avctx,
     VAAPIDecodePictureHEVC *pic = h->ref->hwaccel_picture_private;
     VASliceParameterBufferHEVC *last_slice_param = (VASliceParameterBufferHEVC *)&pic->last_slice_param;
 
-    int slice_param_size = avctx->profile >= FF_PROFILE_HEVC_REXT ?
+    int slice_param_size = avctx->profile >= AV_PROFILE_HEVC_REXT ?
                             sizeof(pic->last_slice_param) : sizeof(VASliceParameterBufferHEVC);
 
     int nb_list = (sh->slice_type == HEVC_SLICE_B) ?
@@ -526,7 +526,7 @@ static int vaapi_hevc_decode_slice(AVCodecContext *avctx,
     fill_pred_weight_table(avctx, h, sh, last_slice_param);
 
 #if VA_CHECK_VERSION(1, 2, 0)
-    if (avctx->profile >= FF_PROFILE_HEVC_REXT) {
+    if (avctx->profile >= AV_PROFILE_HEVC_REXT) {
         pic->last_slice_param.rext = (VASliceParameterBufferHEVCRext) {
             .slice_ext_flags.bits = {
                 .cu_chroma_qp_offset_enabled_flag = sh->cu_chroma_qp_offset_enabled_flag,
diff --git a/libavcodec/vdpau_av1.c b/libavcodec/vdpau_av1.c
index 0ae62301cb..80923092b9 100644
--- a/libavcodec/vdpau_av1.c
+++ b/libavcodec/vdpau_av1.c
@@ -337,13 +337,13 @@ static int vdpau_av1_init(AVCodecContext *avctx)
     uint32_t level = avctx->level;
 
     switch (avctx->profile) {
-    case FF_PROFILE_AV1_MAIN:
+    case AV_PROFILE_AV1_MAIN:
         profile = VDP_DECODER_PROFILE_AV1_MAIN;
         break;
-    case FF_PROFILE_AV1_HIGH:
+    case AV_PROFILE_AV1_HIGH:
         profile = VDP_DECODER_PROFILE_AV1_HIGH;
         break;
-    case FF_PROFILE_AV1_PROFESSIONAL:
+    case AV_PROFILE_AV1_PROFESSIONAL:
         profile = VDP_DECODER_PROFILE_AV1_PROFESSIONAL;
         break;
     default:
diff --git a/libavcodec/vdpau_h264.c b/libavcodec/vdpau_h264.c
index 8694292fe3..9c08e4048c 100644
--- a/libavcodec/vdpau_h264.c
+++ b/libavcodec/vdpau_h264.c
@@ -219,35 +219,35 @@ static int vdpau_h264_init(AVCodecContext *avctx)
     VdpDecoderProfile profile;
     uint32_t level = avctx->level;
 
-    switch (avctx->profile & ~FF_PROFILE_H264_INTRA) {
-    case FF_PROFILE_H264_BASELINE:
+    switch (avctx->profile & ~AV_PROFILE_H264_INTRA) {
+    case AV_PROFILE_H264_BASELINE:
         profile = VDP_DECODER_PROFILE_H264_BASELINE;
         break;
-    case FF_PROFILE_H264_CONSTRAINED_BASELINE:
+    case AV_PROFILE_H264_CONSTRAINED_BASELINE:
 #ifdef VDP_DECODER_PROFILE_H264_CONSTRAINED_BASELINE
         profile = VDP_DECODER_PROFILE_H264_CONSTRAINED_BASELINE;
         break;
 #endif
-    case FF_PROFILE_H264_MAIN:
+    case AV_PROFILE_H264_MAIN:
         profile = VDP_DECODER_PROFILE_H264_MAIN;
         break;
-    case FF_PROFILE_H264_HIGH:
+    case AV_PROFILE_H264_HIGH:
         profile = VDP_DECODER_PROFILE_H264_HIGH;
         break;
 #ifdef VDP_DECODER_PROFILE_H264_EXTENDED
-    case FF_PROFILE_H264_EXTENDED:
+    case AV_PROFILE_H264_EXTENDED:
         profile = VDP_DECODER_PROFILE_H264_EXTENDED;
         break;
 #endif
-    case FF_PROFILE_H264_HIGH_10:
+    case AV_PROFILE_H264_HIGH_10:
         /* XXX: High 10 can be treated as High so long as only 8 bits per
          * format are supported. */
         profile = VDP_DECODER_PROFILE_H264_HIGH;
         break;
 #ifdef VDP_DECODER_PROFILE_H264_HIGH_444_PREDICTIVE
-    case FF_PROFILE_H264_HIGH_422:
-    case FF_PROFILE_H264_HIGH_444_PREDICTIVE:
-    case FF_PROFILE_H264_CAVLC_444:
+    case AV_PROFILE_H264_HIGH_422:
+    case AV_PROFILE_H264_HIGH_444_PREDICTIVE:
+    case AV_PROFILE_H264_CAVLC_444:
         profile = VDP_DECODER_PROFILE_H264_HIGH_444_PREDICTIVE;
         break;
 #endif
@@ -255,7 +255,7 @@ static int vdpau_h264_init(AVCodecContext *avctx)
         return AVERROR(ENOTSUP);
     }
 
-    if ((avctx->profile & FF_PROFILE_H264_INTRA) && avctx->level == 11)
+    if ((avctx->profile & AV_PROFILE_H264_INTRA) && avctx->level == 11)
         level = VDP_DECODER_LEVEL_H264_1b;
 
     return ff_vdpau_common_init(avctx, profile, level);
diff --git a/libavcodec/vdpau_hevc.c b/libavcodec/vdpau_hevc.c
index fea98805d5..4cd7ce5621 100644
--- a/libavcodec/vdpau_hevc.c
+++ b/libavcodec/vdpau_hevc.c
@@ -519,16 +519,16 @@ static int vdpau_hevc_init(AVCodecContext *avctx)
     int ret;
 
     switch (avctx->profile) {
-    case FF_PROFILE_HEVC_MAIN:
+    case AV_PROFILE_HEVC_MAIN:
         profile = VDP_DECODER_PROFILE_HEVC_MAIN;
         break;
-    case FF_PROFILE_HEVC_MAIN_10:
+    case AV_PROFILE_HEVC_MAIN_10:
         profile = VDP_DECODER_PROFILE_HEVC_MAIN_10;
         break;
-    case FF_PROFILE_HEVC_MAIN_STILL_PICTURE:
+    case AV_PROFILE_HEVC_MAIN_STILL_PICTURE:
         profile = VDP_DECODER_PROFILE_HEVC_MAIN_STILL;
         break;
-    case FF_PROFILE_HEVC_REXT:
+    case AV_PROFILE_HEVC_REXT:
         ret = vdpau_hevc_parse_rext_profile(avctx, &profile);
         if (ret)
             return AVERROR(ENOTSUP);
diff --git a/libavcodec/vdpau_mpeg12.c b/libavcodec/vdpau_mpeg12.c
index a5f21ca3a5..bbf76eb469 100644
--- a/libavcodec/vdpau_mpeg12.c
+++ b/libavcodec/vdpau_mpeg12.c
@@ -128,10 +128,10 @@ static int vdpau_mpeg2_init(AVCodecContext *avctx)
     VdpDecoderProfile profile;
 
     switch (avctx->profile) {
-    case FF_PROFILE_MPEG2_MAIN:
+    case AV_PROFILE_MPEG2_MAIN:
         profile = VDP_DECODER_PROFILE_MPEG2_MAIN;
         break;
-    case FF_PROFILE_MPEG2_SIMPLE:
+    case AV_PROFILE_MPEG2_SIMPLE:
         profile = VDP_DECODER_PROFILE_MPEG2_SIMPLE;
         break;
     default:
diff --git a/libavcodec/vdpau_mpeg4.c b/libavcodec/vdpau_mpeg4.c
index 0c3852efdf..055426b95b 100644
--- a/libavcodec/vdpau_mpeg4.c
+++ b/libavcodec/vdpau_mpeg4.c
@@ -95,13 +95,13 @@ static int vdpau_mpeg4_init(AVCodecContext *avctx)
     VdpDecoderProfile profile;
 
     switch (avctx->profile) {
-    case FF_PROFILE_MPEG4_SIMPLE:
+    case AV_PROFILE_MPEG4_SIMPLE:
         profile = VDP_DECODER_PROFILE_MPEG4_PART2_SP;
         break;
     // As any ASP decoder must be able to decode SP, this
     // should be a safe fallback if profile is unknown/unspecified.
-    case FF_PROFILE_UNKNOWN:
-    case FF_PROFILE_MPEG4_ADVANCED_SIMPLE:
+    case AV_PROFILE_UNKNOWN:
+    case AV_PROFILE_MPEG4_ADVANCED_SIMPLE:
         profile = VDP_DECODER_PROFILE_MPEG4_PART2_ASP;
         break;
     default:
diff --git a/libavcodec/vdpau_vc1.c b/libavcodec/vdpau_vc1.c
index a7ab36e431..4e5ee14428 100644
--- a/libavcodec/vdpau_vc1.c
+++ b/libavcodec/vdpau_vc1.c
@@ -121,13 +121,13 @@ static int vdpau_vc1_init(AVCodecContext *avctx)
     VdpDecoderProfile profile;
 
     switch (avctx->profile) {
-    case FF_PROFILE_VC1_SIMPLE:
+    case AV_PROFILE_VC1_SIMPLE:
         profile = VDP_DECODER_PROFILE_VC1_SIMPLE;
         break;
-    case FF_PROFILE_VC1_MAIN:
+    case AV_PROFILE_VC1_MAIN:
         profile = VDP_DECODER_PROFILE_VC1_MAIN;
         break;
-    case FF_PROFILE_VC1_ADVANCED:
+    case AV_PROFILE_VC1_ADVANCED:
         profile = VDP_DECODER_PROFILE_VC1_ADVANCED;
         break;
     default:
diff --git a/libavcodec/vdpau_vp9.c b/libavcodec/vdpau_vp9.c
index fa55101536..424e2e60fb 100644
--- a/libavcodec/vdpau_vp9.c
+++ b/libavcodec/vdpau_vp9.c
@@ -203,16 +203,16 @@ static int vdpau_vp9_init(AVCodecContext *avctx)
     uint32_t level = avctx->level;
 
     switch (avctx->profile) {
-    case FF_PROFILE_VP9_0:
+    case AV_PROFILE_VP9_0:
         profile = VDP_DECODER_PROFILE_VP9_PROFILE_0;
         break;
-    case FF_PROFILE_VP9_1:
+    case AV_PROFILE_VP9_1:
         profile = VDP_DECODER_PROFILE_VP9_PROFILE_1;
         break;
-    case FF_PROFILE_VP9_2:
+    case AV_PROFILE_VP9_2:
         profile = VDP_DECODER_PROFILE_VP9_PROFILE_2;
         break;
-    case FF_PROFILE_VP9_3:
+    case AV_PROFILE_VP9_3:
         profile = VDP_DECODER_PROFILE_VP9_PROFILE_3;
         break;
     default:
diff --git a/libavcodec/version.h b/libavcodec/version.h
index 3ade8a8314..26ee41eb1f 100644
--- a/libavcodec/version.h
+++ b/libavcodec/version.h
@@ -29,8 +29,8 @@
 
 #include "version_major.h"
 
-#define LIBAVCODEC_VERSION_MINOR  25
-#define LIBAVCODEC_VERSION_MICRO 102
+#define LIBAVCODEC_VERSION_MINOR  26
+#define LIBAVCODEC_VERSION_MICRO 100
 
 #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
                                                LIBAVCODEC_VERSION_MINOR, \
diff --git a/libavcodec/version_major.h b/libavcodec/version_major.h
index cfd0b5023e..b9164fe5c6 100644
--- a/libavcodec/version_major.h
+++ b/libavcodec/version_major.h
@@ -51,6 +51,7 @@
 #define FF_API_DROPCHANGED         (LIBAVCODEC_VERSION_MAJOR < 61)
 
 #define FF_API_AVFFT               (LIBAVCODEC_VERSION_MAJOR < 62)
+#define FF_API_FF_PROFILE_LEVEL    (LIBAVCODEC_VERSION_MAJOR < 62)
 
 // reminder to remove CrystalHD decoders on next major bump
 #define FF_CODEC_CRYSTAL_HD        (LIBAVCODEC_VERSION_MAJOR < 61)
diff --git a/libavcodec/videotoolboxenc.c b/libavcodec/videotoolboxenc.c
index 8e493c4f7a..d0a00347b5 100644
--- a/libavcodec/videotoolboxenc.c
+++ b/libavcodec/videotoolboxenc.c
@@ -206,7 +206,7 @@ static void loadVTEncSymbols(void){
     GET_SYM(kVTCompressionPropertyKey_MinAllowedFrameQP, "MinAllowedFrameQP");
 }
 
-#define H264_PROFILE_CONSTRAINED_HIGH (FF_PROFILE_H264_HIGH | FF_PROFILE_H264_CONSTRAINED)
+#define H264_PROFILE_CONSTRAINED_HIGH (AV_PROFILE_H264_HIGH | AV_PROFILE_H264_CONSTRAINED)
 
 typedef enum VTH264Entropy{
     VT_ENTROPY_NOT_SET,
@@ -455,22 +455,22 @@ static CMVideoCodecType get_cm_codec_type(AVCodecContext *avctx,
         return kCMVideoCodecType_HEVC;
     case AV_CODEC_ID_PRORES:
         switch (profile) {
-        case FF_PROFILE_PRORES_PROXY:
+        case AV_PROFILE_PRORES_PROXY:
             return MKBETAG('a','p','c','o'); // kCMVideoCodecType_AppleProRes422Proxy
-        case FF_PROFILE_PRORES_LT:
+        case AV_PROFILE_PRORES_LT:
             return MKBETAG('a','p','c','s'); // kCMVideoCodecType_AppleProRes422LT
-        case FF_PROFILE_PRORES_STANDARD:
+        case AV_PROFILE_PRORES_STANDARD:
             return MKBETAG('a','p','c','n'); // kCMVideoCodecType_AppleProRes422
-        case FF_PROFILE_PRORES_HQ:
+        case AV_PROFILE_PRORES_HQ:
             return MKBETAG('a','p','c','h'); // kCMVideoCodecType_AppleProRes422HQ
-        case FF_PROFILE_PRORES_4444:
+        case AV_PROFILE_PRORES_4444:
             return MKBETAG('a','p','4','h'); // kCMVideoCodecType_AppleProRes4444
-        case FF_PROFILE_PRORES_XQ:
+        case AV_PROFILE_PRORES_XQ:
             return MKBETAG('a','p','4','x'); // kCMVideoCodecType_AppleProRes4444XQ
 
         default:
             av_log(avctx, AV_LOG_ERROR, "Unknown profile ID: %d, using auto\n", profile);
-        case FF_PROFILE_UNKNOWN:
+        case AV_PROFILE_UNKNOWN:
             if (desc &&
                 ((desc->flags & AV_PIX_FMT_FLAG_ALPHA) ||
                   desc->log2_chroma_w == 0))
@@ -736,18 +736,18 @@ static bool get_vt_h264_profile_level(AVCodecContext *avctx,
     VTEncContext *vtctx = avctx->priv_data;
     int profile = vtctx->profile;
 
-    if (profile == FF_PROFILE_UNKNOWN && vtctx->level) {
+    if (profile == AV_PROFILE_UNKNOWN && vtctx->level) {
         //Need to pick a profile if level is not auto-selected.
-        profile = vtctx->has_b_frames ? FF_PROFILE_H264_MAIN : FF_PROFILE_H264_BASELINE;
+        profile = vtctx->has_b_frames ? AV_PROFILE_H264_MAIN : AV_PROFILE_H264_BASELINE;
     }
 
     *profile_level_val = NULL;
 
     switch (profile) {
-        case FF_PROFILE_UNKNOWN:
+        case AV_PROFILE_UNKNOWN:
             return true;
 
-        case FF_PROFILE_H264_BASELINE:
+        case AV_PROFILE_H264_BASELINE:
             switch (vtctx->level) {
                 case  0: *profile_level_val =
                                   compat_keys.kVTProfileLevel_H264_Baseline_AutoLevel; break;
@@ -769,7 +769,7 @@ static bool get_vt_h264_profile_level(AVCodecContext *avctx,
             }
             break;
 
-        case FF_PROFILE_H264_CONSTRAINED_BASELINE:
+        case AV_PROFILE_H264_CONSTRAINED_BASELINE:
             *profile_level_val =  compat_keys.kVTProfileLevel_H264_ConstrainedBaseline_AutoLevel;
 
             if (vtctx->level != 0) {
@@ -781,7 +781,7 @@ static bool get_vt_h264_profile_level(AVCodecContext *avctx,
             }
             break;
 
-        case FF_PROFILE_H264_MAIN:
+        case AV_PROFILE_H264_MAIN:
             switch (vtctx->level) {
                 case  0: *profile_level_val =
                                   compat_keys.kVTProfileLevel_H264_Main_AutoLevel; break;
@@ -812,7 +812,7 @@ static bool get_vt_h264_profile_level(AVCodecContext *avctx,
             }
             break;
 
-        case FF_PROFILE_H264_HIGH:
+        case AV_PROFILE_H264_HIGH:
             switch (vtctx->level) {
                 case  0: *profile_level_val =
                                   compat_keys.kVTProfileLevel_H264_High_AutoLevel; break;
@@ -835,7 +835,7 @@ static bool get_vt_h264_profile_level(AVCodecContext *avctx,
                                   compat_keys.kVTProfileLevel_H264_High_5_2;       break;
             }
             break;
-        case FF_PROFILE_H264_EXTENDED:
+        case AV_PROFILE_H264_EXTENDED:
             switch (vtctx->level) {
                 case  0: *profile_level_val =
                                   compat_keys.kVTProfileLevel_H264_Extended_AutoLevel; break;
@@ -868,13 +868,13 @@ static bool get_vt_hevc_profile_level(AVCodecContext *avctx,
     *profile_level_val = NULL;
 
     switch (profile) {
-        case FF_PROFILE_UNKNOWN:
+        case AV_PROFILE_UNKNOWN:
             return true;
-        case FF_PROFILE_HEVC_MAIN:
+        case AV_PROFILE_HEVC_MAIN:
             *profile_level_val =
                 compat_keys.kVTProfileLevel_HEVC_Main_AutoLevel;
             break;
-        case FF_PROFILE_HEVC_MAIN_10:
+        case AV_PROFILE_HEVC_MAIN_10:
             *profile_level_val =
                 compat_keys.kVTProfileLevel_HEVC_Main10_AutoLevel;
             break;
@@ -1521,12 +1521,12 @@ static int vtenc_configure_encoder(AVCodecContext *avctx)
         vtctx->get_param_set_func = CMVideoFormatDescriptionGetH264ParameterSetAtIndex;
 
         vtctx->has_b_frames = avctx->max_b_frames > 0;
-        if(vtctx->has_b_frames && (0xFF & vtctx->profile) == FF_PROFILE_H264_BASELINE){
+        if(vtctx->has_b_frames && (0xFF & vtctx->profile) == AV_PROFILE_H264_BASELINE){
             av_log(avctx, AV_LOG_WARNING, "Cannot use B-frames with baseline profile. Output will not contain B-frames.\n");
             vtctx->has_b_frames = 0;
         }
 
-        if (vtctx->entropy == VT_CABAC && (0xFF & vtctx->profile) == FF_PROFILE_H264_BASELINE) {
+        if (vtctx->entropy == VT_CABAC && (0xFF & vtctx->profile) == AV_PROFILE_H264_BASELINE) {
             av_log(avctx, AV_LOG_WARNING, "CABAC entropy requires 'main' or 'high' profile, but baseline was requested. Encode will not use CABAC entropy.\n");
             vtctx->entropy = VT_ENTROPY_NOT_SET;
         }
@@ -1632,7 +1632,7 @@ static av_cold int vtenc_init(AVCodecContext *avctx)
     pthread_cond_init(&vtctx->cv_sample_sent, NULL);
 
     // It can happen when user set avctx->profile directly.
-    if (vtctx->profile == FF_PROFILE_UNKNOWN)
+    if (vtctx->profile == AV_PROFILE_UNKNOWN)
         vtctx->profile = avctx->profile;
     vtctx->session = NULL;
     status = vtenc_configure_encoder(avctx);
@@ -2778,13 +2778,13 @@ static const enum AVPixelFormat prores_pix_fmts[] = {
 
 #define OFFSET(x) offsetof(VTEncContext, x)
 static const AVOption h264_options[] = {
-    { "profile", "Profile", OFFSET(profile), AV_OPT_TYPE_INT, { .i64 = FF_PROFILE_UNKNOWN }, FF_PROFILE_UNKNOWN, INT_MAX, VE, "profile" },
-    { "baseline",             "Baseline Profile",             0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_BASELINE             }, INT_MIN, INT_MAX, VE, "profile" },
-    { "constrained_baseline", "Constrained Baseline Profile", 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_CONSTRAINED_BASELINE }, INT_MIN, INT_MAX, VE, "profile" },
-    { "main",                 "Main Profile",                 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_MAIN                 }, INT_MIN, INT_MAX, VE, "profile" },
-    { "high",                 "High Profile",                 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_HIGH                 }, INT_MIN, INT_MAX, VE, "profile" },
+    { "profile", "Profile", OFFSET(profile), AV_OPT_TYPE_INT, { .i64 = AV_PROFILE_UNKNOWN }, AV_PROFILE_UNKNOWN, INT_MAX, VE, "profile" },
+    { "baseline",             "Baseline Profile",             0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_H264_BASELINE             }, INT_MIN, INT_MAX, VE, "profile" },
+    { "constrained_baseline", "Constrained Baseline Profile", 0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_H264_CONSTRAINED_BASELINE }, INT_MIN, INT_MAX, VE, "profile" },
+    { "main",                 "Main Profile",                 0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_H264_MAIN                 }, INT_MIN, INT_MAX, VE, "profile" },
+    { "high",                 "High Profile",                 0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_H264_HIGH                 }, INT_MIN, INT_MAX, VE, "profile" },
     { "constrained_high",     "Constrained High Profile",     0, AV_OPT_TYPE_CONST, { .i64 = H264_PROFILE_CONSTRAINED_HIGH        }, INT_MIN, INT_MAX, VE, "profile" },
-    { "extended",             "Extend Profile",               0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_H264_EXTENDED             }, INT_MIN, INT_MAX, VE, "profile" },
+    { "extended",             "Extend Profile",               0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_H264_EXTENDED             }, INT_MIN, INT_MAX, VE, "profile" },
 
     { "level", "Level", OFFSET(level), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 52, VE, "level" },
     { "1.3", "Level 1.3, only available with Baseline Profile", 0, AV_OPT_TYPE_CONST, { .i64 = 13 }, INT_MIN, INT_MAX, VE, "level" },
@@ -2835,9 +2835,9 @@ const FFCodec ff_h264_videotoolbox_encoder = {
 };
 
 static const AVOption hevc_options[] = {
-    { "profile", "Profile", OFFSET(profile), AV_OPT_TYPE_INT, { .i64 = FF_PROFILE_UNKNOWN }, FF_PROFILE_UNKNOWN, INT_MAX, VE, "profile" },
-    { "main",     "Main Profile",     0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_HEVC_MAIN    }, INT_MIN, INT_MAX, VE, "profile" },
-    { "main10",   "Main10 Profile",   0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_HEVC_MAIN_10 }, INT_MIN, INT_MAX, VE, "profile" },
+    { "profile", "Profile", OFFSET(profile), AV_OPT_TYPE_INT, { .i64 = AV_PROFILE_UNKNOWN }, AV_PROFILE_UNKNOWN, INT_MAX, VE, "profile" },
+    { "main",     "Main Profile",     0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_HEVC_MAIN    }, INT_MIN, INT_MAX, VE, "profile" },
+    { "main10",   "Main10 Profile",   0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_HEVC_MAIN_10 }, INT_MIN, INT_MAX, VE, "profile" },
 
     { "alpha_quality", "Compression quality for the alpha channel", OFFSET(alpha_quality), AV_OPT_TYPE_DOUBLE, { .dbl = 0.0 }, 0.0, 1.0, VE },
 
@@ -2872,14 +2872,14 @@ const FFCodec ff_hevc_videotoolbox_encoder = {
 };
 
 static const AVOption prores_options[] = {
-    { "profile", "Profile", OFFSET(profile), AV_OPT_TYPE_INT, { .i64 = FF_PROFILE_UNKNOWN }, FF_PROFILE_UNKNOWN, FF_PROFILE_PRORES_XQ, VE, "profile" },
-    { "auto",     "Automatically determine based on input format", 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_UNKNOWN },            INT_MIN, INT_MAX, VE, "profile" },
-    { "proxy",    "ProRes 422 Proxy",                              0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_PRORES_PROXY },       INT_MIN, INT_MAX, VE, "profile" },
-    { "lt",       "ProRes 422 LT",                                 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_PRORES_LT },          INT_MIN, INT_MAX, VE, "profile" },
-    { "standard", "ProRes 422",                                    0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_PRORES_STANDARD },    INT_MIN, INT_MAX, VE, "profile" },
-    { "hq",       "ProRes 422 HQ",                                 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_PRORES_HQ },          INT_MIN, INT_MAX, VE, "profile" },
-    { "4444",     "ProRes 4444",                                   0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_PRORES_4444 },        INT_MIN, INT_MAX, VE, "profile" },
-    { "xq",       "ProRes 4444 XQ",                                0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_PRORES_XQ },          INT_MIN, INT_MAX, VE, "profile" },
+    { "profile", "Profile", OFFSET(profile), AV_OPT_TYPE_INT, { .i64 = AV_PROFILE_UNKNOWN }, AV_PROFILE_UNKNOWN, AV_PROFILE_PRORES_XQ, VE, "profile" },
+    { "auto",     "Automatically determine based on input format", 0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_UNKNOWN },            INT_MIN, INT_MAX, VE, "profile" },
+    { "proxy",    "ProRes 422 Proxy",                              0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_PRORES_PROXY },       INT_MIN, INT_MAX, VE, "profile" },
+    { "lt",       "ProRes 422 LT",                                 0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_PRORES_LT },          INT_MIN, INT_MAX, VE, "profile" },
+    { "standard", "ProRes 422",                                    0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_PRORES_STANDARD },    INT_MIN, INT_MAX, VE, "profile" },
+    { "hq",       "ProRes 422 HQ",                                 0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_PRORES_HQ },          INT_MIN, INT_MAX, VE, "profile" },
+    { "4444",     "ProRes 4444",                                   0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_PRORES_4444 },        INT_MIN, INT_MAX, VE, "profile" },
+    { "xq",       "ProRes 4444 XQ",                                0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_PRORES_XQ },          INT_MIN, INT_MAX, VE, "profile" },
 
     COMMON_OPTIONS
     { NULL },
diff --git a/libavcodec/vulkan_decode.c b/libavcodec/vulkan_decode.c
index 1b2ff0045d..9a57369df7 100644
--- a/libavcodec/vulkan_decode.c
+++ b/libavcodec/vulkan_decode.c
@@ -696,8 +696,8 @@ static VkResult vulkan_setup_profile(AVCodecContext *avctx,
 
         /* Vulkan transmits all the constrant_set flags, rather than wanting them
          * merged in the profile IDC */
-        h264_profile->stdProfileIdc = cur_profile & ~(FF_PROFILE_H264_CONSTRAINED |
-                                                      FF_PROFILE_H264_INTRA);
+        h264_profile->stdProfileIdc = cur_profile & ~(AV_PROFILE_H264_CONSTRAINED |
+                                                      AV_PROFILE_H264_INTRA);
 
         h264_profile->pictureLayout = avctx->field_order == AV_FIELD_UNKNOWN ||
                                       avctx->field_order == AV_FIELD_PROGRESSIVE ?
@@ -789,8 +789,8 @@ static int vulkan_decode_get_profile(AVCodecContext *avctx, AVBufferRef *frames_
     }
 
     cur_profile = avctx->profile;
-    base_profile = avctx->codec_id == AV_CODEC_ID_H264 ? FF_PROFILE_H264_CONSTRAINED_BASELINE :
-                   avctx->codec_id == AV_CODEC_ID_H265 ? FF_PROFILE_HEVC_MAIN :
+    base_profile = avctx->codec_id == AV_CODEC_ID_H264 ? AV_PROFILE_H264_CONSTRAINED_BASELINE :
+                   avctx->codec_id == AV_CODEC_ID_H265 ? AV_PROFILE_HEVC_MAIN :
                    avctx->codec_id == AV_CODEC_ID_AV1  ? STD_VIDEO_AV1_MESA_PROFILE_MAIN :
                    0;
 
diff --git a/libavformat/av1.c b/libavformat/av1.c
index b6eaf50627..4455ec0504 100644
--- a/libavformat/av1.c
+++ b/libavformat/av1.c
@@ -23,7 +23,7 @@
 #include "libavutil/mem.h"
 #include "libavcodec/av1.h"
 #include "libavcodec/av1_parse.h"
-#include "libavcodec/avcodec.h"
+#include "libavcodec/defs.h"
 #include "libavcodec/put_bits.h"
 #include "av1.h"
 #include "avio.h"
@@ -141,12 +141,12 @@ static int parse_color_config(AV1SequenceParameters *seq_params, GetBitContext *
 {
     int twelve_bit = 0;
     int high_bitdepth = get_bits1(gb);
-    if (seq_params->profile == FF_PROFILE_AV1_PROFESSIONAL && high_bitdepth)
+    if (seq_params->profile == AV_PROFILE_AV1_PROFESSIONAL && high_bitdepth)
         twelve_bit = get_bits1(gb);
 
     seq_params->bitdepth = 8 + (high_bitdepth * 2) + (twelve_bit * 2);
 
-    if (seq_params->profile == FF_PROFILE_AV1_HIGH)
+    if (seq_params->profile == AV_PROFILE_AV1_HIGH)
         seq_params->monochrome = 0;
     else
         seq_params->monochrome = get_bits1(gb);
@@ -176,10 +176,10 @@ static int parse_color_config(AV1SequenceParameters *seq_params, GetBitContext *
     } else {
         seq_params->color_range = get_bits1(gb);
 
-        if (seq_params->profile == FF_PROFILE_AV1_MAIN) {
+        if (seq_params->profile == AV_PROFILE_AV1_MAIN) {
             seq_params->chroma_subsampling_x = 1;
             seq_params->chroma_subsampling_y = 1;
-        } else if (seq_params->profile == FF_PROFILE_AV1_HIGH) {
+        } else if (seq_params->profile == AV_PROFILE_AV1_HIGH) {
             seq_params->chroma_subsampling_x = 0;
             seq_params->chroma_subsampling_y = 0;
         } else {
diff --git a/libavformat/hlsenc.c b/libavformat/hlsenc.c
index 004bd25359..12e20580ee 100644
--- a/libavformat/hlsenc.c
+++ b/libavformat/hlsenc.c
@@ -39,7 +39,7 @@
 #include "libavutil/time.h"
 #include "libavutil/time_internal.h"
 
-#include "libavcodec/avcodec.h"
+#include "libavcodec/defs.h"
 
 #include "avformat.h"
 #include "avio_internal.h"
@@ -369,12 +369,12 @@ static void write_codec_attr(AVStream *st, VariantStream *vs)
         }
     } else if (st->codecpar->codec_id == AV_CODEC_ID_HEVC) {
         uint8_t *data = st->codecpar->extradata;
-        int profile = FF_PROFILE_UNKNOWN;
-        int level = FF_LEVEL_UNKNOWN;
+        int profile = AV_PROFILE_UNKNOWN;
+        int level = AV_LEVEL_UNKNOWN;
 
-        if (st->codecpar->profile != FF_PROFILE_UNKNOWN)
+        if (st->codecpar->profile != AV_PROFILE_UNKNOWN)
             profile = st->codecpar->profile;
-        if (st->codecpar->level != FF_LEVEL_UNKNOWN)
+        if (st->codecpar->level != AV_LEVEL_UNKNOWN)
             level = st->codecpar->level;
 
         /* check the boundary of data which from current position is small than extradata_size */
@@ -407,8 +407,8 @@ static void write_codec_attr(AVStream *st, VariantStream *vs)
             data++;
         }
         if (st->codecpar->codec_tag == MKTAG('h','v','c','1') &&
-            profile != FF_PROFILE_UNKNOWN &&
-            level != FF_LEVEL_UNKNOWN) {
+            profile != AV_PROFILE_UNKNOWN &&
+            level != AV_LEVEL_UNKNOWN) {
             snprintf(attr, sizeof(attr), "%s.%d.4.L%d.B01", av_fourcc2str(st->codecpar->codec_tag), profile, level);
         } else
             goto fail;
diff --git a/libavformat/matroskadec.c b/libavformat/matroskadec.c
index 0d6f153d18..638e07c13d 100644
--- a/libavformat/matroskadec.c
+++ b/libavformat/matroskadec.c
@@ -51,8 +51,8 @@
 #include "libavutil/time_internal.h"
 #include "libavutil/spherical.h"
 
-#include "libavcodec/avcodec.h"
 #include "libavcodec/bytestream.h"
+#include "libavcodec/defs.h"
 #include "libavcodec/flac.h"
 #include "libavcodec/mpeg4audio.h"
 #include "libavcodec/packet_internal.h"
@@ -3037,21 +3037,21 @@ static int mkv_parse_subtitle_codec(MatroskaTrack *track, AVStream *st,
                 // [0x30..0x37] are component tags utilized for
                 // non-mobile captioning service ("profile A").
                 if (component_tag >= 0x30 && component_tag <= 0x37) {
-                    par->profile = FF_PROFILE_ARIB_PROFILE_A;
+                    par->profile = AV_PROFILE_ARIB_PROFILE_A;
                 }
                 break;
             case 0x0012:
                 // component tag 0x87 signifies a mobile/partial reception
                 // (1seg) captioning service ("profile C").
                 if (component_tag == 0x87) {
-                    par->profile = FF_PROFILE_ARIB_PROFILE_C;
+                    par->profile = AV_PROFILE_ARIB_PROFILE_C;
                 }
                 break;
             default:
                 break;
             }
 
-            if (par->profile == FF_PROFILE_UNKNOWN)
+            if (par->profile == AV_PROFILE_UNKNOWN)
                 av_log(matroska->ctx, AV_LOG_WARNING,
                        "Unknown ARIB caption profile utilized: %02x / %04x\n",
                        component_tag, data_component_id);
diff --git a/libavformat/matroskaenc.c b/libavformat/matroskaenc.c
index bf2ca7106b..ba54f5f98e 100644
--- a/libavformat/matroskaenc.c
+++ b/libavformat/matroskaenc.c
@@ -59,9 +59,9 @@
 #include "libavutil/stereo3d.h"
 
 #include "libavcodec/av1.h"
-#include "libavcodec/avcodec.h"
 #include "libavcodec/bytestream.h"
 #include "libavcodec/codec_desc.h"
+#include "libavcodec/defs.h"
 #include "libavcodec/xiph.h"
 #include "libavcodec/mpeg4audio.h"
 
@@ -1154,11 +1154,11 @@ static int mkv_assemble_native_codecprivate(AVFormatContext *s, AVIOContext *dyn
     case AV_CODEC_ID_ARIB_CAPTION: {
         unsigned stream_identifier, data_component_id;
         switch (par->profile) {
-        case FF_PROFILE_ARIB_PROFILE_A:
+        case AV_PROFILE_ARIB_PROFILE_A:
             stream_identifier = 0x30;
             data_component_id = 0x0008;
             break;
-        case FF_PROFILE_ARIB_PROFILE_C:
+        case AV_PROFILE_ARIB_PROFILE_C:
             stream_identifier = 0x87;
             data_component_id = 0x0012;
             break;
diff --git a/libavformat/movenc.c b/libavformat/movenc.c
index 696ae5a6c9..ab92263cd7 100644
--- a/libavformat/movenc.c
+++ b/libavformat/movenc.c
@@ -1757,8 +1757,8 @@ static const struct {
 static int mov_get_dnxhd_codec_tag(AVFormatContext *s, MOVTrack *track)
 {
   int tag = MKTAG('A','V','d','n');
-  if (track->par->profile != FF_PROFILE_UNKNOWN &&
-      track->par->profile != FF_PROFILE_DNXHD)
+  if (track->par->profile != AV_PROFILE_UNKNOWN &&
+      track->par->profile != AV_PROFILE_DNXHD)
       tag = MKTAG('A','V','d','h');
   return tag;
 }
@@ -4766,10 +4766,10 @@ static int mov_write_isml_manifest(AVIOContext *pb, MOVMuxContext *mov, AVFormat
             if (track->par->codec_id == AV_CODEC_ID_AAC) {
                 switch (track->par->profile)
                 {
-                    case FF_PROFILE_AAC_HE_V2:
+                    case AV_PROFILE_AAC_HE_V2:
                         param_write_string(pb, "FourCC", "AACP");
                         break;
-                    case FF_PROFILE_AAC_HE:
+                    case AV_PROFILE_AAC_HE:
                         param_write_string(pb, "FourCC", "AACH");
                         break;
                     default:
diff --git a/libavformat/mpegts.c b/libavformat/mpegts.c
index 0b3edda817..8fd1524a8a 100644
--- a/libavformat/mpegts.c
+++ b/libavformat/mpegts.c
@@ -34,6 +34,7 @@
 #include "libavutil/dovi_meta.h"
 #include "libavcodec/avcodec.h"
 #include "libavcodec/bytestream.h"
+#include "libavcodec/defs.h"
 #include "libavcodec/get_bits.h"
 #include "libavcodec/opus.h"
 #include "avformat.h"
@@ -2147,7 +2148,7 @@ int ff_parse_mpeg2_descriptor(AVFormatContext *fc, AVStream *st, int stream_type
             // Component tag limits are documented in TR-B14, fascicle 2,
             // Vol. 3, Section 2, 4.2.8.1
             int actual_component_tag = sti->stream_identifier - 1;
-            int picked_profile = FF_PROFILE_UNKNOWN;
+            int picked_profile = AV_PROFILE_UNKNOWN;
             int data_component_id = get16(pp, desc_end);
             if (data_component_id < 0)
                 return AVERROR_INVALIDDATA;
@@ -2158,21 +2159,21 @@ int ff_parse_mpeg2_descriptor(AVFormatContext *fc, AVStream *st, int stream_type
                 // non-mobile captioning service ("profile A").
                 if (actual_component_tag >= 0x30 &&
                     actual_component_tag <= 0x37) {
-                    picked_profile = FF_PROFILE_ARIB_PROFILE_A;
+                    picked_profile = AV_PROFILE_ARIB_PROFILE_A;
                 }
                 break;
             case 0x0012:
                 // component tag 0x87 signifies a mobile/partial reception
                 // (1seg) captioning service ("profile C").
                 if (actual_component_tag == 0x87) {
-                    picked_profile = FF_PROFILE_ARIB_PROFILE_C;
+                    picked_profile = AV_PROFILE_ARIB_PROFILE_C;
                 }
                 break;
             default:
                 break;
             }
 
-            if (picked_profile == FF_PROFILE_UNKNOWN)
+            if (picked_profile == AV_PROFILE_UNKNOWN)
                 break;
 
             st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
diff --git a/libavformat/mpegtsenc.c b/libavformat/mpegtsenc.c
index 700fc549df..46ed16985f 100644
--- a/libavformat/mpegtsenc.c
+++ b/libavformat/mpegtsenc.c
@@ -28,8 +28,8 @@
 #include "libavutil/opt.h"
 
 #include "libavcodec/ac3_parser_internal.h"
-#include "libavcodec/avcodec.h"
 #include "libavcodec/bytestream.h"
+#include "libavcodec/defs.h"
 #include "libavcodec/h264.h"
 #include "libavcodec/startcode.h"
 
@@ -300,11 +300,11 @@ static int put_arib_caption_descriptor(AVFormatContext *s, uint8_t **q_ptr,
     uint8_t *q = *q_ptr;
 
     switch (codecpar->profile) {
-    case FF_PROFILE_ARIB_PROFILE_A:
+    case AV_PROFILE_ARIB_PROFILE_A:
         stream_identifier = 0x30;
         data_component_id = 0x0008;
         break;
-    case FF_PROFILE_ARIB_PROFILE_C:
+    case AV_PROFILE_ARIB_PROFILE_C:
         stream_identifier = 0x87;
         data_component_id = 0x0012;
         break;
@@ -431,7 +431,7 @@ static int get_dvb_stream_type(AVFormatContext *s, AVStream *st)
         stream_type = STREAM_TYPE_PRIVATE_DATA;
         break;
     case AV_CODEC_ID_SMPTE_KLV:
-        if (st->codecpar->profile == FF_PROFILE_KLVA_SYNC) {
+        if (st->codecpar->profile == AV_PROFILE_KLVA_SYNC) {
             stream_type = STREAM_TYPE_METADATA;
         } else {
             stream_type = STREAM_TYPE_PRIVATE_DATA;
diff --git a/libavformat/mxfdec.c b/libavformat/mxfdec.c
index 110b69b7c1..7dbe294d23 100644
--- a/libavformat/mxfdec.c
+++ b/libavformat/mxfdec.c
@@ -52,6 +52,7 @@
 #include "libavutil/mastering_display_metadata.h"
 #include "libavutil/mathematics.h"
 #include "libavcodec/bytestream.h"
+#include "libavcodec/defs.h"
 #include "libavcodec/internal.h"
 #include "libavutil/channel_layout.h"
 #include "libavutil/dict_internal.h"
@@ -1403,8 +1404,8 @@ static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int
         }
         if (IS_KLV_KEY(uid, mxf_jp2k_rsiz)) {
             uint32_t rsiz = avio_rb16(pb);
-            if (rsiz == FF_PROFILE_JPEG2000_DCINEMA_2K ||
-                rsiz == FF_PROFILE_JPEG2000_DCINEMA_4K)
+            if (rsiz == AV_PROFILE_JPEG2000_DCINEMA_2K ||
+                rsiz == AV_PROFILE_JPEG2000_DCINEMA_4K)
                 descriptor->pix_fmt = AV_PIX_FMT_XYZ12;
         }
         if (IS_KLV_KEY(uid, mxf_mastering_display_prefix)) {
diff --git a/libavformat/mxfenc.c b/libavformat/mxfenc.c
index d8252ed68f..cb299412e2 100644
--- a/libavformat/mxfenc.c
+++ b/libavformat/mxfenc.c
@@ -47,7 +47,7 @@
 #include "libavutil/mastering_display_metadata.h"
 #include "libavutil/pixdesc.h"
 #include "libavutil/time_internal.h"
-#include "libavcodec/avcodec.h"
+#include "libavcodec/defs.h"
 #include "libavcodec/golomb.h"
 #include "libavcodec/h264.h"
 #include "libavcodec/packet_internal.h"
@@ -2111,12 +2111,12 @@ static const struct {
     int profile;
     UID codec_ul;
 } mxf_prores_codec_uls[] = {
-    { FF_PROFILE_PRORES_PROXY,    { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x01,0x00 } },
-    { FF_PROFILE_PRORES_LT,       { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x02,0x00 } },
-    { FF_PROFILE_PRORES_STANDARD, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x03,0x00 } },
-    { FF_PROFILE_PRORES_HQ,       { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x04,0x00 } },
-    { FF_PROFILE_PRORES_4444,     { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x05,0x00 } },
-    { FF_PROFILE_PRORES_XQ,       { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x06,0x00 } },
+    { AV_PROFILE_PRORES_PROXY,    { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x01,0x00 } },
+    { AV_PROFILE_PRORES_LT,       { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x02,0x00 } },
+    { AV_PROFILE_PRORES_STANDARD, { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x03,0x00 } },
+    { AV_PROFILE_PRORES_HQ,       { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x04,0x00 } },
+    { AV_PROFILE_PRORES_4444,     { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x05,0x00 } },
+    { AV_PROFILE_PRORES_XQ,       { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x0d,0x04,0x01,0x02,0x02,0x03,0x06,0x06,0x00 } },
 };
 
 static int mxf_parse_prores_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt)
diff --git a/libavformat/vpcc.c b/libavformat/vpcc.c
index 256407dd6d..a5977916bf 100644
--- a/libavformat/vpcc.c
+++ b/libavformat/vpcc.c
@@ -21,7 +21,7 @@
 
 #include "libavutil/pixdesc.h"
 #include "libavutil/pixfmt.h"
-#include "libavcodec/avcodec.h"
+#include "libavcodec/defs.h"
 #include "libavcodec/get_bits.h"
 #include "vpcc.h"
 
@@ -155,7 +155,7 @@ int ff_isom_get_vpcc_features(AVFormatContext *s, AVCodecParameters *par,
                               AVRational *frame_rate, VPCC *vpcc)
 {
     int profile = par->profile;
-    int level = par->level == FF_LEVEL_UNKNOWN ?
+    int level = par->level == AV_LEVEL_UNKNOWN ?
         get_vp9_level(par, frame_rate) : par->level;
     int bit_depth = get_bit_depth(s, par->format);
     int vpx_chroma_subsampling =
@@ -166,7 +166,7 @@ int ff_isom_get_vpcc_features(AVFormatContext *s, AVCodecParameters *par,
     if (bit_depth < 0 || vpx_chroma_subsampling < 0)
         return AVERROR_INVALIDDATA;
 
-    if (len && (profile == FF_PROFILE_UNKNOWN || !bit_depth)) {
+    if (len && (profile == AV_PROFILE_UNKNOWN || !bit_depth)) {
         GetBitContext gb;
 
         int ret = init_get_bits8(&gb, data, len);
@@ -176,16 +176,16 @@ int ff_isom_get_vpcc_features(AVFormatContext *s, AVCodecParameters *par,
         parse_bitstream(&gb, &profile, &bit_depth);
     }
 
-    if (profile == FF_PROFILE_UNKNOWN && bit_depth) {
+    if (profile == AV_PROFILE_UNKNOWN && bit_depth) {
         if (vpx_chroma_subsampling == VPX_SUBSAMPLING_420_VERTICAL ||
             vpx_chroma_subsampling == VPX_SUBSAMPLING_420_COLLOCATED_WITH_LUMA) {
-            profile = (bit_depth == 8) ? FF_PROFILE_VP9_0 : FF_PROFILE_VP9_2;
+            profile = (bit_depth == 8) ? AV_PROFILE_VP9_0 : AV_PROFILE_VP9_2;
         } else {
-            profile = (bit_depth == 8) ? FF_PROFILE_VP9_1 : FF_PROFILE_VP9_3;
+            profile = (bit_depth == 8) ? AV_PROFILE_VP9_1 : AV_PROFILE_VP9_3;
         }
     }
 
-    if (profile == FF_PROFILE_UNKNOWN || !bit_depth)
+    if (profile == AV_PROFILE_UNKNOWN || !bit_depth)
         av_log(s, AV_LOG_WARNING, "VP9 profile and/or bit depth not set or could not be derived\n");
 
     vpcc->profile            = profile;




More information about the ffmpeg-cvslog mailing list