diff --git a/doc/examples/demuxing_decoding.c b/doc/examples/demuxing_decoding.c
index 8520d5b660..670f08779d 100644
--- a/doc/examples/demuxing_decoding.c
+++ b/doc/examples/demuxing_decoding.c
@@ -155,7 +155,7 @@ static int open_codec_context(int *stream_idx,
     ret = av_find_best_stream(fmt_ctx, type, -1, -1, NULL, 0);
     if (ret < 0) {
         fprintf(stderr, "Could not find %s stream in input file '%s'\n",
-                av_get_media_type_string(type), src_filename);
+                av_media_type_get_string(type), src_filename);
         return ret;
     } else {
         stream_index = ret;
@@ -165,7 +165,7 @@ static int open_codec_context(int *stream_idx,
         dec = avcodec_find_decoder(st->codecpar->codec_id);
         if (!dec) {
             fprintf(stderr, "Failed to find %s codec\n",
-                    av_get_media_type_string(type));
+                    av_media_type_get_string(type));
             return AVERROR(EINVAL);
         }
 
@@ -173,21 +173,21 @@ static int open_codec_context(int *stream_idx,
         *dec_ctx = avcodec_alloc_context3(dec);
         if (!*dec_ctx) {
             fprintf(stderr, "Failed to allocate the %s codec context\n",
-                    av_get_media_type_string(type));
+                    av_media_type_get_string(type));
             return AVERROR(ENOMEM);
         }
 
         /* Copy codec parameters from input stream to output codec context */
         if ((ret = avcodec_parameters_to_context(*dec_ctx, st->codecpar)) < 0) {
             fprintf(stderr, "Failed to copy %s codec parameters to decoder context\n",
-                    av_get_media_type_string(type));
+                    av_media_type_get_string(type));
             return ret;
         }
 
         /* Init the decoders */
         if ((ret = avcodec_open2(*dec_ctx, dec, NULL)) < 0) {
             fprintf(stderr, "Failed to open %s codec\n",
-                    av_get_media_type_string(type));
+                    av_media_type_get_string(type));
             return ret;
         }
         *stream_idx = stream_index;
diff --git a/doc/examples/extract_mvs.c b/doc/examples/extract_mvs.c
index cc1311da91..2fb5517708 100644
--- a/doc/examples/extract_mvs.c
+++ b/doc/examples/extract_mvs.c
@@ -85,7 +85,7 @@ static int open_codec_context(AVFormatContext *fmt_ctx, enum AVMediaType type)
     ret = av_find_best_stream(fmt_ctx, type, -1, -1, &dec, 0);
     if (ret < 0) {
         fprintf(stderr, "Could not find %s stream in input file '%s'\n",
-                av_get_media_type_string(type), src_filename);
+                av_media_type_get_string(type), src_filename);
         return ret;
     } else {
         int stream_idx = ret;
@@ -109,7 +109,7 @@ static int open_codec_context(AVFormatContext *fmt_ctx, enum AVMediaType type)
         av_dict_free(&opts);
         if (ret < 0) {
             fprintf(stderr, "Failed to open %s codec\n",
-                    av_get_media_type_string(type));
+                    av_media_type_get_string(type));
             return ret;
         }
 
diff --git a/fftools/cmdutils.c b/fftools/cmdutils.c
index 4b50e15eef..4504d2711c 100644
--- a/fftools/cmdutils.c
+++ b/fftools/cmdutils.c
@@ -1961,7 +1961,7 @@ static void show_help_filter(const char *name)
     count = avfilter_filter_pad_count(f, 0);
     for (i = 0; i < count; i++) {
         printf("       #%d: %s (%s)\n", i, avfilter_pad_get_name(f->inputs, i),
-               media_type_string(avfilter_pad_get_type(f->inputs, i)));
+               av_media_type_get_string(avfilter_pad_get_type(f->inputs, i)));
     }
     if (f->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)
         printf("        dynamic (depending on the options)\n");
@@ -1972,7 +1972,7 @@ static void show_help_filter(const char *name)
     count = avfilter_filter_pad_count(f, 1);
     for (i = 0; i < count; i++) {
         printf("       #%d: %s (%s)\n", i, avfilter_pad_get_name(f->outputs, i),
-               media_type_string(avfilter_pad_get_type(f->outputs, i)));
+               av_media_type_get_string(avfilter_pad_get_type(f->outputs, i)));
     }
     if (f->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS)
         printf("        dynamic (depending on the options)\n");
@@ -2253,10 +2253,9 @@ static void print_device_list(const AVDeviceInfoList *device_list)
             device->device_name, device->device_description);
         if (device->nb_media_types > 0) {
             for (int j = 0; j < device->nb_media_types; ++j) {
-                const char* media_type = av_get_media_type_string(device->media_types[j]);
                 if (j > 0)
                     printf(", ");
-                printf("%s", media_type ? media_type : "unknown");
+                printf("%s", av_media_type_get_string(device->media_types[j]));
             }
         } else {
             printf("none");
diff --git a/fftools/cmdutils.h b/fftools/cmdutils.h
index 50eed9b13a..a3e06b7b29 100644
--- a/fftools/cmdutils.h
+++ b/fftools/cmdutils.h
@@ -642,8 +642,6 @@ void *grow_array(void *array, int elem_size, int *size, int new_size);
  */
 void *allocate_array_elem(void *array, size_t elem_size, int *nb_elems);
 
-#define media_type_string av_get_media_type_string
-
 #define GROW_ARRAY(array, nb_elems)\
     array = grow_array(array, sizeof(*array), &nb_elems, nb_elems + 1)
 
diff --git a/fftools/ffmpeg.c b/fftools/ffmpeg.c
index 7beea11933..bd26adf35b 100644
--- a/fftools/ffmpeg.c
+++ b/fftools/ffmpeg.c
@@ -844,7 +844,7 @@ static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int u
     if (debug_ts) {
         av_log(NULL, AV_LOG_INFO, "muxer <- type:%s "
                 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s size:%d\n",
-                av_get_media_type_string(ost->enc_ctx->codec_type),
+                av_media_type_get_string(ost->enc_ctx->codec_type),
                 av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &ost->st->time_base),
                 av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &ost->st->time_base),
                 pkt->size
@@ -1602,7 +1602,7 @@ static void print_final_stats(int64_t total_size)
             total_packets += ist->nb_packets;
 
             av_log(NULL, AV_LOG_VERBOSE, "  Input stream #%d:%d (%s): ",
-                   i, j, media_type_string(type));
+                   i, j, av_media_type_get_string(type));
             av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets read (%"PRIu64" bytes); ",
                    ist->nb_packets, ist->data_size);
 
@@ -1636,7 +1636,7 @@ static void print_final_stats(int64_t total_size)
             total_packets += ost->packets_written;
 
             av_log(NULL, AV_LOG_VERBOSE, "  Output stream #%d:%d (%s): ",
-                   i, j, media_type_string(type));
+                   i, j, av_media_type_get_string(type));
             if (ost->encoding_needed) {
                 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames encoded",
                        ost->frames_encoded);
@@ -3565,7 +3565,7 @@ static void report_new_stream(int input_index, AVPacket *pkt)
         return;
     av_log(file->ctx, AV_LOG_WARNING,
            "New %s stream %d:%d at pos:%"PRId64" and DTS:%ss\n",
-           av_get_media_type_string(st->codecpar->codec_type),
+           av_media_type_get_string(st->codecpar->codec_type),
            input_index, pkt->stream_index,
            pkt->pos, av_ts2timestr(pkt->dts, &st->time_base));
     file->nb_streams_warn = pkt->stream_index + 1;
@@ -4298,7 +4298,7 @@ static int process_input(int file_index)
     if (debug_ts) {
         av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
                "next_dts:%s next_dts_time:%s next_pts:%s next_pts_time:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%s off_time:%s\n",
-               ifile->ist_index + pkt->stream_index, av_get_media_type_string(ist->dec_ctx->codec_type),
+               ifile->ist_index + pkt->stream_index, av_media_type_get_string(ist->dec_ctx->codec_type),
                av_ts2str(ist->next_dts), av_ts2timestr(ist->next_dts, &AV_TIME_BASE_Q),
                av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &AV_TIME_BASE_Q),
                av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &ist->st->time_base),
@@ -4425,7 +4425,7 @@ static int process_input(int file_index)
                        "timestamp discontinuity for stream #%d:%d "
                        "(id=%d, type=%s): %"PRId64", new offset= %"PRId64"\n",
                        ist->file_index, ist->st->index, ist->st->id,
-                       av_get_media_type_string(ist->dec_ctx->codec_type),
+                       av_media_type_get_string(ist->dec_ctx->codec_type),
                        delta, ifile->ts_offset);
                 pkt->dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
                 if (pkt->pts != AV_NOPTS_VALUE)
@@ -4454,7 +4454,7 @@ static int process_input(int file_index)
 
     if (debug_ts) {
         av_log(NULL, AV_LOG_INFO, "demuxer+ffmpeg -> ist_index:%d type:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%s off_time:%s\n",
-               ifile->ist_index + pkt->stream_index, av_get_media_type_string(ist->dec_ctx->codec_type),
+               ifile->ist_index + pkt->stream_index, av_media_type_get_string(ist->dec_ctx->codec_type),
                av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &ist->st->time_base),
                av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &ist->st->time_base),
                av_ts2str(input_files[ist->file_index]->ts_offset),
diff --git a/fftools/ffmpeg_opt.c b/fftools/ffmpeg_opt.c
index 3102851885..653dee6d67 100644
--- a/fftools/ffmpeg_opt.c
+++ b/fftools/ffmpeg_opt.c
@@ -1694,7 +1694,7 @@ static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
                "Filtering and streamcopy cannot be used together.\n",
                ost->filters ? "Filtergraph" : "Filtergraph script",
                ost->filters ? ost->filters : ost->filters_script,
-               av_get_media_type_string(type), ost->file_index, ost->index);
+               av_media_type_get_string(type), ost->file_index, ost->index);
         exit_program(1);
     }
 }
diff --git a/fftools/ffplay.c b/fftools/ffplay.c
index ac48d8765d..2cc9804770 100644
--- a/fftools/ffplay.c
+++ b/fftools/ffplay.c
@@ -2868,7 +2868,7 @@ static int read_thread(void *arg)
     }
     for (i = 0; i < AVMEDIA_TYPE_NB; i++) {
         if (wanted_stream_spec[i] && st_index[i] == -1) {
-            av_log(NULL, AV_LOG_ERROR, "Stream specifier %s does not match any %s stream\n", wanted_stream_spec[i], av_get_media_type_string(i));
+            av_log(NULL, AV_LOG_ERROR, "Stream specifier %s does not match any %s stream\n", wanted_stream_spec[i], av_media_type_get_string(i));
             st_index[i] = INT_MAX;
         }
     }
@@ -3199,7 +3199,7 @@ static void stream_cycle_channel(VideoState *is, int codec_type)
     if (p && stream_index != -1)
         stream_index = p->stream_index[stream_index];
     av_log(NULL, AV_LOG_INFO, "Switch %s stream from #%d to #%d\n",
-           av_get_media_type_string(codec_type),
+           av_media_type_get_string(codec_type),
            old_index,
            stream_index);
 
diff --git a/fftools/ffprobe.c b/fftools/ffprobe.c
index 8a8e3de540..32723177a0 100644
--- a/fftools/ffprobe.c
+++ b/fftools/ffprobe.c
@@ -2327,15 +2327,12 @@ static void show_packet(WriterContext *w, InputFile *ifile, AVPacket *pkt, int p
     char val_str[128];
     AVStream *st = ifile->streams[pkt->stream_index].st;
     AVBPrint pbuf;
-    const char *s;
 
     av_bprint_init(&pbuf, 1, AV_BPRINT_SIZE_UNLIMITED);
 
     writer_print_section_header(w, SECTION_ID_PACKET);
 
-    s = av_get_media_type_string(st->codecpar->codec_type);
-    if (s) print_str    ("codec_type", s);
-    else   print_str_opt("codec_type", "unknown");
+    print_str("codec_type", av_media_type_get_string(st->codecpar->codec_type));
     print_int("stream_index",     pkt->stream_index);
     print_ts  ("pts",             pkt->pts);
     print_time("pts_time",        pkt->pts, &st->time_base);
@@ -2410,9 +2407,7 @@ static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream,
 
     writer_print_section_header(w, SECTION_ID_FRAME);
 
-    s = av_get_media_type_string(stream->codecpar->codec_type);
-    if (s) print_str    ("media_type", s);
-    else   print_str_opt("media_type", "unknown");
+    print_str("media_type", av_media_type_get_string(stream->codecpar->codec_type));
     print_int("stream_index",           stream->index);
     print_int("key_frame",              frame->key_frame);
     print_ts  ("pts",                   frame->pts);
@@ -2809,9 +2804,7 @@ static int show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_id
             print_str_opt("profile", "unknown");
     }
 
-    s = av_get_media_type_string(par->codec_type);
-    if (s) print_str    ("codec_type", s);
-    else   print_str_opt("codec_type", "unknown");
+    print_str("codec_type", av_media_type_get_string(par->codec_type));
 
     /* print AVI/FourCC tag */
     print_str("codec_tag_string",    av_fourcc2str(par->codec_tag));
diff --git a/libavcodec/avcodec.c b/libavcodec/avcodec.c
index 4df834c708..ee4155d4e6 100644
--- a/libavcodec/avcodec.c
+++ b/libavcodec/avcodec.c
@@ -526,7 +526,7 @@ void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
     if (!buf || buf_size <= 0)
         return;
     av_bprint_init_for_buffer(&bprint, buf, buf_size);
-    codec_type = av_get_media_type_string(enc->codec_type);
+    codec_type = av_media_type_get_string(enc->codec_type);
     codec_name = avcodec_get_name(enc->codec_id);
     profile = avcodec_profile_name(enc->codec_id, enc->profile);
 
diff --git a/libavcodec/tests/avcodec.c b/libavcodec/tests/avcodec.c
index 5d0ff9432c..34ab01bc2a 100644
--- a/libavcodec/tests/avcodec.c
+++ b/libavcodec/tests/avcodec.c
@@ -21,12 +21,6 @@
 #include "libavcodec/codec_desc.h"
 #include "libavcodec/internal.h"
 
-static const char *get_type_string(enum AVMediaType type)
-{
-    const char *ret = av_get_media_type_string(type);
-    return ret ? ret : "unknown";
-}
-
 #define AV_LOG(...) av_log(NULL, AV_LOG_FATAL, __VA_ARGS__)
 #define ERR_INTERNAL(msg, ...)                                  \
 do {                                                            \
@@ -74,7 +68,7 @@ int main(void){
             codec->type != AVMEDIA_TYPE_AUDIO &&
             codec->type != AVMEDIA_TYPE_SUBTITLE)
             ERR_EXT("Codec %s has unsupported type %s\n",
-                    get_type_string(codec->type));
+                    av_media_type_get_string(codec->type));
         if (codec->type != AVMEDIA_TYPE_AUDIO) {
             if (codec->channel_layouts || codec->sample_fmts ||
                 codec->supported_samplerates)
@@ -158,7 +152,7 @@ int main(void){
         } else if (desc->type != codec->type)
             ERR_EXT("The type of AVCodec %s and its AVCodecDescriptor differ: "
                     "%s vs %s\n",
-                    get_type_string(codec->type), get_type_string(desc->type));
+                    av_media_type_get_string(codec->type), av_media_type_get_string(desc->type));
     }
     return ret;
 }
diff --git a/libavdevice/dshow.c b/libavdevice/dshow.c
index 3a16f3720f..6ecb9c848b 100644
--- a/libavdevice/dshow.c
+++ b/libavdevice/dshow.c
@@ -577,10 +577,10 @@ dshow_cycle_devices(AVFormatContext *avctx, ICreateDevEnum *devenum,
             else {
                 av_log(avctx, AV_LOG_INFO, "\"%s\"", friendly_name);
                 if (nb_media_types > 0) {
-                    const char* media_type = av_get_media_type_string(media_types[0]);
+                    const char* media_type = av_media_type_get_string(media_types[0]);
                     av_log(avctx, AV_LOG_INFO, " (%s", media_type ? media_type : "unknown");
                     for (int i = 1; i < nb_media_types; ++i) {
-                        media_type = av_get_media_type_string(media_types[i]);
+                        media_type = av_media_type_get_string(media_types[i]);
                         av_log(avctx, AV_LOG_INFO, ", %s", media_type ? media_type : "unknown");
                     }
                     av_log(avctx, AV_LOG_INFO, ")");
diff --git a/libavfilter/avfilter.c b/libavfilter/avfilter.c
index 7362bcdab5..a991a6272e 100644
--- a/libavfilter/avfilter.c
+++ b/libavfilter/avfilter.c
@@ -174,8 +174,8 @@ int avfilter_link(AVFilterContext *src, unsigned srcpad,
     if (src->output_pads[srcpad].type != dst->input_pads[dstpad].type) {
         av_log(src, AV_LOG_ERROR,
                "Media type mismatch between the '%s' filter output pad %d (%s) and the '%s' filter input pad %d (%s)\n",
-               src->name, srcpad, (char *)av_x_if_null(av_get_media_type_string(src->output_pads[srcpad].type), "?"),
-               dst->name, dstpad, (char *)av_x_if_null(av_get_media_type_string(dst-> input_pads[dstpad].type), "?"));
+               src->name, srcpad, av_media_type_get_string(src->output_pads[srcpad].type),
+               dst->name, dstpad, av_media_type_get_string(dst-> input_pads[dstpad].type));
         return AVERROR(EINVAL);
     }
 
diff --git a/libavfilter/avfiltergraph.c b/libavfilter/avfiltergraph.c
index b8b432e98b..fa971734d1 100644
--- a/libavfilter/avfiltergraph.c
+++ b/libavfilter/avfiltergraph.c
@@ -220,7 +220,7 @@ static int graph_check_validity(AVFilterGraph *graph, void *log_ctx)
                 pad = &filt->input_pads[j];
                 av_log(log_ctx, AV_LOG_ERROR,
                        "Input pad \"%s\" with type %s of the filter instance \"%s\" of %s not connected to any source\n",
-                       pad->name, av_get_media_type_string(pad->type), filt->name, filt->filter->name);
+                       pad->name, av_media_type_get_string(pad->type), filt->name, filt->filter->name);
                 return AVERROR(EINVAL);
             }
         }
@@ -230,7 +230,7 @@ static int graph_check_validity(AVFilterGraph *graph, void *log_ctx)
                 pad = &filt->output_pads[j];
                 av_log(log_ctx, AV_LOG_ERROR,
                        "Output pad \"%s\" with type %s of the filter instance \"%s\" of %s not connected to any destination\n",
-                       pad->name, av_get_media_type_string(pad->type), filt->name, filt->filter->name);
+                       pad->name, av_media_type_get_string(pad->type), filt->name, filt->filter->name);
                 return AVERROR(EINVAL);
             }
         }
diff --git a/libavfilter/src_movie.c b/libavfilter/src_movie.c
index b89a680883..b09f5698fb 100644
--- a/libavfilter/src_movie.c
+++ b/libavfilter/src_movie.c
@@ -113,7 +113,7 @@ static AVStream *find_stream(void *log, AVFormatContext *avf, const char *spec)
         ret = av_find_best_stream(avf, type, stream_id, -1, NULL, 0);
         if (ret < 0) {
             av_log(log, AV_LOG_ERROR, "No %s stream with index '%d' found\n",
-                   av_get_media_type_string(type), stream_id);
+                   av_media_type_get_string(type), stream_id);
             return NULL;
         }
         return avf->streams[ret];
@@ -148,7 +148,7 @@ static AVStream *find_stream(void *log, AVFormatContext *avf, const char *spec)
         found->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
         av_log(log, AV_LOG_ERROR, "Stream specifier \"%s\" matched a %s stream,"
                "currently unsupported by libavfilter\n", spec,
-               av_get_media_type_string(found->codecpar->codec_type));
+               av_media_type_get_string(found->codecpar->codec_type));
         return NULL;
     }
     return found;
@@ -426,7 +426,7 @@ static char *describe_frame_to_str(char *dst, size_t dst_size,
                  frame->nb_samples);
                  break;
     default:
-        snprintf(dst, dst_size, "%s BUG", av_get_media_type_string(frame_type));
+        snprintf(dst, dst_size, "%s BUG", av_media_type_get_string(frame_type));
         break;
     }
     return dst;
diff --git a/libavformat/avienc.c b/libavformat/avienc.c
index be2493ce55..ec72a74eec 100644
--- a/libavformat/avienc.c
+++ b/libavformat/avienc.c
@@ -473,7 +473,7 @@ static int avi_write_header(AVFormatContext *s)
             default:
                 av_log(s, AV_LOG_ERROR,
                     "Invalid or not supported codec type '%s' found in the input\n",
-                    (char *)av_x_if_null(av_get_media_type_string(par->codec_type), "?"));
+                    av_media_type_get_string(par->codec_type));
                 return AVERROR(EINVAL);
             }
             ff_end_tag(pb, strf);
diff --git a/libavformat/flvenc.c b/libavformat/flvenc.c
index 66c530a2ff..1267ed00a8 100644
--- a/libavformat/flvenc.c
+++ b/libavformat/flvenc.c
@@ -670,7 +670,7 @@ static int flv_init(struct AVFormatContext *s)
             break;
         default:
             av_log(s, AV_LOG_ERROR, "Codec type '%s' for stream %d is not compatible with FLV\n",
-                   av_get_media_type_string(par->codec_type), i);
+                   av_media_type_get_string(par->codec_type), i);
             return AVERROR(EINVAL);
         }
         avpriv_set_pts_info(s->streams[i], 32, 1, 1000); /* 32 bit pts in ms */
diff --git a/libavformat/framehash.c b/libavformat/framehash.c
index 04c40825b9..b9f765f097 100644
--- a/libavformat/framehash.c
+++ b/libavformat/framehash.c
@@ -32,7 +32,7 @@ int ff_framehash_write_header(AVFormatContext *s)
         AVCodecParameters *avctx = st->codecpar;
         char buf[256] = { 0 };
         avio_printf(s->pb, "#tb %d: %d/%d\n", i, st->time_base.num, st->time_base.den);
-        avio_printf(s->pb, "#media_type %d: %s\n", i, av_get_media_type_string(avctx->codec_type));
+        avio_printf(s->pb, "#media_type %d: %s\n", i, av_media_type_get_string(avctx->codec_type));
         avio_printf(s->pb, "#codec_id %d: %s\n", i, avcodec_get_name(avctx->codec_id));
         switch (avctx->codec_type) {
         case AVMEDIA_TYPE_AUDIO:
diff --git a/libavformat/mov.c b/libavformat/mov.c
index a80fcc1606..b2041ec160 100644
--- a/libavformat/mov.c
+++ b/libavformat/mov.c
@@ -7141,7 +7141,7 @@ static int mov_read_kind(MOVContext *c, AVIOContext *pb, MOVAtom atom)
 
     av_log(ctx, AV_LOG_TRACE,
            "%s stream %d KindBox(scheme: %s, value: %s)\n",
-           av_get_media_type_string(st->codecpar->codec_type),
+           av_media_type_get_string(st->codecpar->codec_type),
            st->index,
            scheme_buf.str, value_buf.str);
 
diff --git a/libavformat/mpegenc.c b/libavformat/mpegenc.c
index 64248695bd..cf1c89a04b 100644
--- a/libavformat/mpegenc.c
+++ b/libavformat/mpegenc.c
@@ -456,7 +456,7 @@ static av_cold int mpeg_mux_init(AVFormatContext *ctx)
             break;
         default:
             av_log(ctx, AV_LOG_ERROR, "Invalid media type %s for output stream #%d\n",
-                   av_get_media_type_string(st->codecpar->codec_type), i);
+                   av_media_type_get_string(st->codecpar->codec_type), i);
             return AVERROR(EINVAL);
         }
         stream->fifo = av_fifo_alloc2(16, 1, 0);
diff --git a/libavformat/mpegts.c b/libavformat/mpegts.c
index e23f596490..dfb898d07b 100644
--- a/libavformat/mpegts.c
+++ b/libavformat/mpegts.c
@@ -2253,7 +2253,7 @@ static AVStream *find_matching_stream(MpegTSContext *ts, int pid, unsigned int p
     if (found) {
         av_log(ts->stream, AV_LOG_VERBOSE,
                "re-using existing %s stream %d (pid=0x%x) for new pid=0x%x\n",
-               av_get_media_type_string(found->codecpar->codec_type),
+               av_media_type_get_string(found->codecpar->codec_type),
                found->index, found->id, pid);
     }
 
diff --git a/libavformat/mxfdec.c b/libavformat/mxfdec.c
index b85c10bf19..5763c5db8b 100644
--- a/libavformat/mxfdec.c
+++ b/libavformat/mxfdec.c
@@ -2404,7 +2404,7 @@ static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
         av_dict_set(&st->metadata, "track_name", track->name, 0);
 
     codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &track->sequence->data_definition_ul);
-    av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
+    av_dict_set(&st->metadata, "data_type", av_media_type_get_string(codec_ul->id), 0);
     return 0;
 }
 
diff --git a/libavformat/segment.c b/libavformat/segment.c
index e9b0aa4fa8..2fac2647a1 100644
--- a/libavformat/segment.c
+++ b/libavformat/segment.c
@@ -737,7 +737,7 @@ static int seg_init(AVFormatContext *s)
         return ret;
     av_log(s, AV_LOG_VERBOSE, "Selected stream id:%d type:%s\n",
            seg->reference_stream_index,
-           av_get_media_type_string(s->streams[seg->reference_stream_index]->codecpar->codec_type));
+           av_media_type_get_string(s->streams[seg->reference_stream_index]->codecpar->codec_type));
 
     seg->oformat = av_guess_format(seg->format, s->url, NULL);
 
diff --git a/libavformat/tee.c b/libavformat/tee.c
index b3bcd70b9f..97db7c789b 100644
--- a/libavformat/tee.c
+++ b/libavformat/tee.c
@@ -419,7 +419,7 @@ static void log_slave(TeeSlave *slave, void *log_ctx, int log_level)
 
         av_log(log_ctx, log_level, "    stream:%d codec:%s type:%s",
                i, avcodec_get_name(st->codecpar->codec_id),
-               av_get_media_type_string(st->codecpar->codec_type));
+               av_media_type_get_string(st->codecpar->codec_type));
 
         bsf_name = bsf->filter->priv_class ?
                    bsf->filter->priv_class->item_name(bsf) : bsf->filter->name;
diff --git a/libavformat/uncodedframecrcenc.c b/libavformat/uncodedframecrcenc.c
index e30fe4ddb9..04e8818711 100644
--- a/libavformat/uncodedframecrcenc.c
+++ b/libavformat/uncodedframecrcenc.c
@@ -130,7 +130,6 @@ static int write_frame(struct AVFormatContext *s, int stream_index,
     AVBPrint bp;
     int ret = 0;
     enum AVMediaType type;
-    const char *type_name;
 
     if ((flags & AV_WRITE_UNCODED_FRAME_QUERY))
         return 0;
@@ -139,8 +138,7 @@ static int write_frame(struct AVFormatContext *s, int stream_index,
     av_bprintf(&bp, "%d, %10"PRId64"",
                stream_index, (*frame)->pts);
     type = s->streams[stream_index]->codecpar->codec_type;
-    type_name = av_get_media_type_string(type);
-    av_bprintf(&bp, ", %s", type_name ? type_name : "unknown");
+    av_bprintf(&bp, ", %s", av_media_type_get_string(type));
     switch (type) {
         case AVMEDIA_TYPE_VIDEO:
             video_frame_cksum(&bp, *frame);
