obs-ffmpeg: Remove compatibility with FFmpeg < 6.1

plugins/obs-ffmpeg/cmake/dependencies.cmake

@@ -1,12 +1,6 @@
-if(OS_WINDOWS OR OS_MACOS)
-  set(ffmpeg_version 6)
-else()
-  set(ffmpeg_version 4.4)
-endif()
-
 find_package(
   FFmpeg
-  ${ffmpeg_version}
+  6.1
   REQUIRED avcodec avfilter avdevice avutil swscale avformat swresample
 )
 

plugins/obs-ffmpeg/ffmpeg-mux/ffmpeg-mux.c

@@ -482,13 +482,6 @@ static void create_video_stream(struct ffmpeg_mux *ffm)
 		(AVRational){ffm->params.fps_den, ffm->params.fps_num};
 
 	ffm->video_stream->time_base = context->time_base;
-#if LIBAVFORMAT_VERSION_MAJOR < 59
-	// codec->time_base may still be used if LIBAVFORMAT_VERSION_MAJOR < 59
-	PRAGMA_WARN_PUSH
-	PRAGMA_WARN_DEPRECATION
-	ffm->video_stream->codec->time_base = context->time_base;
-	PRAGMA_WARN_POP
-#endif
 	ffm->video_stream->avg_frame_rate = av_inv_q(context->time_base);
 
 	if (ffm->output->oformat->flags & AVFMT_GLOBALHEADER)
@@ -503,17 +496,11 @@ static void create_video_stream(struct ffmpeg_mux *ffm)
 			av_content_light_metadata_alloc(&content_size);
 		content->MaxCLL = max_luminance;
 		content->MaxFALL = max_luminance;
-#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(60, 31, 102)
-		av_stream_add_side_data(ffm->video_stream,
-					AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
-					(uint8_t *)content, content_size);
-#else
 		av_packet_side_data_add(
 			&ffm->video_stream->codecpar->coded_side_data,
 			&ffm->video_stream->codecpar->nb_coded_side_data,
 			AV_PKT_DATA_CONTENT_LIGHT_LEVEL, (uint8_t *)content,
 			content_size, 0);
-#endif
 
 		AVMasteringDisplayMetadata *const mastering =
 			av_mastering_display_metadata_alloc();
@@ -529,18 +516,11 @@ static void create_video_stream(struct ffmpeg_mux *ffm)
 		mastering->max_luminance = av_make_q(max_luminance, 1);
 		mastering->has_primaries = 1;
 		mastering->has_luminance = 1;
-#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(60, 31, 102)
-		av_stream_add_side_data(ffm->video_stream,
-					AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
-					(uint8_t *)mastering,
-					sizeof(*mastering));
-#else
 		av_packet_side_data_add(
 			&ffm->video_stream->codecpar->coded_side_data,
 			&ffm->video_stream->codecpar->nb_coded_side_data,
 			AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
 			(uint8_t *)mastering, sizeof(*mastering), 0);
-#endif
 	}
 
 	ffm->video_ctx = context;
@@ -586,9 +566,6 @@ static void create_audio_stream(struct ffmpeg_mux *ffm, int idx)
 		context->bit_rate = (int64_t)ffm->audio[idx].abitrate * 1000;
 
 	channels = ffm->audio[idx].channels;
-#if LIBAVUTIL_VERSION_INT < AV_VERSION_INT(57, 24, 100)
-	context->channels = channels;
-#endif
 	context->sample_rate = ffm->audio[idx].sample_rate;
 	if (!(codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE))
 		context->frame_size = ffm->audio[idx].frame_size;
@@ -596,17 +573,10 @@ static void create_audio_stream(struct ffmpeg_mux *ffm, int idx)
 	context->time_base = stream->time_base;
 	context->extradata = extradata;
 	context->extradata_size = ffm->audio_header[idx].size;
-#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(59, 24, 100)
-	context->channel_layout = av_get_default_channel_layout(channels);
-	//avutil default channel layout for 5 channels is 5.0 ; fix for 4.1
-	if (channels == 5)
-		context->channel_layout = av_get_channel_layout("4.1");
-#else
 	av_channel_layout_default(&context->ch_layout, channels);
 	//avutil default channel layout for 5 channels is 5.0 ; fix for 4.1
 	if (channels == 5)
 		context->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_4POINT1;
-#endif
 	if (ffm->output->oformat->flags & AVFMT_GLOBALHEADER)
 		context->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
 
@@ -937,11 +907,7 @@ static int ffmpeg_mux_write_av_buffer(void *opaque, uint8_t *buf, int buf_size)
 
 static inline int open_output_file(struct ffmpeg_mux *ffm)
 {
-#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(59, 0, 100)
-	AVOutputFormat *format = ffm->output->oformat;
-#else
 	const AVOutputFormat *format = ffm->output->oformat;
-#endif
 	int ret;
 
 	if ((format->flags & AVFMT_NOFILE) == 0) {
@@ -1033,11 +999,7 @@ static inline int open_output_file(struct ffmpeg_mux *ffm)
 
 static int ffmpeg_mux_init_context(struct ffmpeg_mux *ffm)
 {
-#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(59, 0, 100)
-	AVOutputFormat *output_format;
-#else
 	const AVOutputFormat *output_format;
-#endif
 	int ret;
 	bool is_http = false;
 	is_http = (strncmp(ffm->params.file, HTTP_PROTO,
@@ -1074,16 +1036,6 @@ static int ffmpeg_mux_init_context(struct ffmpeg_mux *ffm)
 		return FFM_ERROR;
 	}
 
-#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(59, 0, 100)
-	ffm->output->oformat->video_codec = AV_CODEC_ID_NONE;
-	ffm->output->oformat->audio_codec = AV_CODEC_ID_NONE;
-#endif
-
-#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(60, 0, 100)
-	/* Allow FLAC/OPUS in MP4 */
-	ffm->output->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
-#endif
-
 	if (!init_streams(ffm)) {
 		free_avformat(ffm);
 		return FFM_ERROR;

plugins/obs-ffmpeg/obs-ffmpeg-audio-encoders.c

@@ -56,33 +56,6 @@ struct enc_encoder {
 	int frame_size_bytes;
 };
 
-#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(59, 24, 100)
-static inline uint64_t convert_speaker_layout(enum speaker_layout layout)
-{
-	switch (layout) {
-	case SPEAKERS_UNKNOWN:
-		return 0;
-	case SPEAKERS_MONO:
-		return AV_CH_LAYOUT_MONO;
-	case SPEAKERS_STEREO:
-		return AV_CH_LAYOUT_STEREO;
-	case SPEAKERS_2POINT1:
-		return AV_CH_LAYOUT_SURROUND;
-	case SPEAKERS_4POINT0:
-		return AV_CH_LAYOUT_4POINT0;
-	case SPEAKERS_4POINT1:
-		return AV_CH_LAYOUT_4POINT1;
-	case SPEAKERS_5POINT1:
-		return AV_CH_LAYOUT_5POINT1_BACK;
-	case SPEAKERS_7POINT1:
-		return AV_CH_LAYOUT_7POINT1;
-	}
-
-	/* shouldn't get here */
-	return 0;
-}
-#endif
-
 static const char *aac_getname(void *unused)
 {
 	UNUSED_PARAMETER(unused);
@@ -164,17 +137,8 @@ static bool initialize_codec(struct enc_encoder *enc)
 		return false;
 	}
 	enc->aframe->format = enc->context->sample_fmt;
-#if LIBAVUTIL_VERSION_INT < AV_VERSION_INT(57, 24, 100)
-	enc->aframe->channels = enc->context->channels;
-	channels = enc->context->channels;
-#else
 	channels = enc->context->ch_layout.nb_channels;
-#endif
-#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(59, 24, 100)
-	enc->aframe->channel_layout = enc->context->channel_layout;
-#else
 	enc->aframe->ch_layout = enc->context->ch_layout;
-#endif
 	enc->aframe->sample_rate = enc->context->sample_rate;
 
 	enc->frame_size = enc->context->frame_size;
@@ -262,13 +226,6 @@ static void *enc_create(obs_data_t *settings, obs_encoder_t *encoder,
 	const struct audio_output_info *aoi;
 	aoi = audio_output_get_info(audio);
 
-#if LIBAVUTIL_VERSION_INT < AV_VERSION_INT(57, 24, 100)
-	enc->context->channels = (int)audio_output_get_channels(audio);
-#endif
-
-#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(59, 24, 100)
-	enc->context->channel_layout = convert_speaker_layout(aoi->speakers);
-#else
 	av_channel_layout_default(&enc->context->ch_layout,
 				  (int)audio_output_get_channels(audio));
 	/* The avutil default channel layout for 5 channels is 5.0, which OBS
@@ -286,7 +243,6 @@ static void *enc_create(obs_data_t *settings, obs_encoder_t *encoder,
 	    astrcmpi(enc->type, "alac") == 0)
 		enc->context->ch_layout =
 			(AVChannelLayout)AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK;
-#endif
 
 	enc->context->sample_rate = audio_output_get_sample_rate(audio);
 
@@ -330,18 +286,11 @@ static void *enc_create(obs_data_t *settings, obs_encoder_t *encoder,
 			enc->context->sample_rate = closest;
 	}
 
-#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(59, 24, 100)
-	info("bitrate: %" PRId64 ", channels: %d, channel_layout: %x\n",
-	     (int64_t)enc->context->bit_rate / 1000,
-	     (int)enc->context->channels,
-	     (unsigned int)enc->context->channel_layout);
-#else
 	char buf[256];
 	av_channel_layout_describe(&enc->context->ch_layout, buf, 256);
 	info("bitrate: %" PRId64 ", channels: %d, channel_layout: %s\n",
 	     (int64_t)enc->context->bit_rate / 1000,
 	     (int)enc->context->ch_layout.nb_channels, buf);
-#endif
 	init_sizes(enc, audio);
 
 	/* enable experimental FFmpeg encoder if the only one available */
@@ -409,12 +358,8 @@ static bool do_encode(struct enc_encoder *enc, struct encoder_packet *packet,
 	enc->aframe->pts = av_rescale_q(
 		enc->total_samples, (AVRational){1, enc->context->sample_rate},
 		enc->context->time_base);
-#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(57, 24, 100)
 	enc->aframe->ch_layout = enc->context->ch_layout;
 	channels = enc->context->ch_layout.nb_channels;
-#else
-	channels = enc->context->channels;
-#endif
 	ret = avcodec_fill_audio_frame(enc->aframe, channels,
 				       enc->context->sample_fmt,
 				       enc->samples[0],
@@ -497,11 +442,7 @@ static void enc_audio_info(void *data, struct audio_convert_info *info)
 {
 	struct enc_encoder *enc = data;
 	int channels;
-#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(57, 24, 100)
 	channels = enc->context->ch_layout.nb_channels;
-#else
-	channels = enc->context->channels;
-#endif
 	info->format = convert_ffmpeg_sample_format(enc->context->sample_fmt);
 	info->samples_per_sec = (uint32_t)enc->context->sample_rate;
 	if (channels != 7 && channels <= 8)

plugins/obs-ffmpeg/obs-ffmpeg-av1.c

@@ -88,11 +88,7 @@ static bool av1_update(struct av1_encoder *enc, obs_data_t *settings)
 	if (enc->type == AV1_ENCODER_TYPE_SVT) {
 		av_opt_set_int(enc->ffve.context->priv_data, "preset", preset,
 			       0);
-#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59, 37, 100)
 		av_dict_set_int(&svtav1_opts, "rc", 1, 0);
-#else
-		av_opt_set(enc->ffve.context->priv_data, "rc", "vbr", 0);
-#endif
 	} else if (enc->type == AV1_ENCODER_TYPE_AOM) {
 		av_opt_set_int(enc->ffve.context->priv_data, "cpu-used", preset,
 			       0);
@@ -114,16 +110,9 @@ static bool av1_update(struct av1_encoder *enc, obs_data_t *settings)
 		av_opt_set_int(enc->ffve.context->priv_data, "crf", cqp, 0);
 
 		if (enc->type == AV1_ENCODER_TYPE_SVT) {
-#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59, 37, 100)
 			av_dict_set_int(&svtav1_opts, "rc", 0, 0);
 			av_opt_set_int(enc->ffve.context->priv_data, "qp", cqp,
 				       0);
-#else
-			av_opt_set(enc->ffve.context->priv_data, "rc", "cqp",
-				   0);
-			av_opt_set_int(enc->ffve.context->priv_data, "qp", cqp,
-				       0);
-#endif
 		}
 
 	} else if (astrcmpi(rc, "vbr") != 0) { /* CBR by default */
@@ -132,16 +121,10 @@ static bool av1_update(struct av1_encoder *enc, obs_data_t *settings)
 		cqp = 0;
 
 		if (enc->type == AV1_ENCODER_TYPE_SVT) {
-#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(59, 37, 100)
 			av_dict_set_int(&svtav1_opts, "rc", 2, 0);
 			av_dict_set_int(&svtav1_opts, "pred-struct", 1, 0);
 			av_dict_set_int(&svtav1_opts, "bias-pct", 0, 0);
 			av_dict_set_int(&svtav1_opts, "tbr", rate, 0);
-#else
-			enc->ffve.context->rc_max_rate = rate;
-			av_opt_set(enc->ffve.context->priv_data, "rc", "cvbr",
-				   0);
-#endif
 		} else {
 			enc->ffve.context->rc_max_rate = rate;
 		}

plugins/obs-ffmpeg/obs-ffmpeg-compat.h

@@ -11,8 +11,3 @@
 	  LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(a, b, c)) || \
 	 (LIBAVCODEC_VERSION_MICRO >= 100 &&                    \
 	  LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(a, d, e)))
-
-#if LIBAVCODEC_VERSION_MAJOR < 60
-#define CODEC_CAP_TRUNC AV_CODEC_CAP_TRUNCATED
-#define CODEC_FLAG_TRUNC AV_CODEC_FLAG_TRUNCATED
-#endif

plugins/obs-ffmpeg/obs-ffmpeg-formats.h

@@ -48,20 +48,16 @@ obs_to_ffmpeg_video_format(enum video_format format)
 		return AV_PIX_FMT_YUVA422P;
 	case VIDEO_FORMAT_YUVA:
 		return AV_PIX_FMT_YUVA444P;
-#if LIBAVUTIL_BUILD >= AV_VERSION_INT(56, 31, 100)
 	case VIDEO_FORMAT_YA2L:
 		return AV_PIX_FMT_YUVA444P12LE;
-#endif
 	case VIDEO_FORMAT_I010:
 		return AV_PIX_FMT_YUV420P10LE;
 	case VIDEO_FORMAT_P010:
 		return AV_PIX_FMT_P010LE;
-#if LIBAVUTIL_BUILD >= AV_VERSION_INT(57, 17, 100)
 	case VIDEO_FORMAT_P216:
 		return AV_PIX_FMT_P216LE;
 	case VIDEO_FORMAT_P416:
 		return AV_PIX_FMT_P416LE;
-#endif
 	case VIDEO_FORMAT_NONE:
 	case VIDEO_FORMAT_AYUV:
 	default:

plugins/obs-ffmpeg/obs-ffmpeg-mpegts.c

@@ -175,9 +175,6 @@ static bool create_video_stream(struct ffmpeg_output *stream,
 	context->thread_count = 0;
 
 	data->video->time_base = context->time_base;
-#if LIBAVFORMAT_VERSION_MAJOR < 59
-	data->video->codec->time_base = context->time_base;
-#endif
 	data->video->avg_frame_rate = av_inv_q(context->time_base);
 
 	data->video_ctx = context;
@@ -198,17 +195,11 @@ static bool create_video_stream(struct ffmpeg_output *stream,
 			av_content_light_metadata_alloc(&content_size);
 		content->MaxCLL = hdr_nominal_peak_level;
 		content->MaxFALL = hdr_nominal_peak_level;
-#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(60, 31, 102)
-		av_stream_add_side_data(data->video,
-					AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
-					(uint8_t *)content, content_size);
-#else
 		av_packet_side_data_add(
 			&data->video->codecpar->coded_side_data,
 			&data->video->codecpar->nb_coded_side_data,
 			AV_PKT_DATA_CONTENT_LIGHT_LEVEL, (uint8_t *)content,
 			content_size, 0);
-#endif
 
 		AVMasteringDisplayMetadata *const mastering =
 			av_mastering_display_metadata_alloc();
@@ -224,18 +215,11 @@ static bool create_video_stream(struct ffmpeg_output *stream,
 		mastering->max_luminance = av_make_q(hdr_nominal_peak_level, 1);
 		mastering->has_primaries = 1;
 		mastering->has_luminance = 1;
-#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(60, 31, 102)
-		av_stream_add_side_data(data->video,
-					AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
-					(uint8_t *)mastering,
-					sizeof(*mastering));
-#else
 		av_packet_side_data_add(
 			&data->video->codecpar->coded_side_data,
 			&data->video->codecpar->nb_coded_side_data,
 			AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
 			(uint8_t *)mastering, sizeof(*mastering), 0);
-#endif
 	}
 
 	return true;
@@ -270,23 +254,11 @@ static bool create_audio_stream(struct ffmpeg_output *stream,
 	context->bit_rate = (int64_t)data->config.audio_bitrates[idx] * 1000;
 	context->time_base = (AVRational){1, aoi.samples_per_sec};
 	channels = get_audio_channels(aoi.speakers);
-#if LIBAVUTIL_VERSION_INT < AV_VERSION_INT(57, 24, 100)
-	context->channels = get_audio_channels(aoi.speakers);
-#endif
 	context->sample_rate = aoi.samples_per_sec;
 
-#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(59, 24, 100)
-	context->channel_layout =
-		av_get_default_channel_layout(context->channels);
-
-	//avutil default channel layout for 5 channels is 5.0 ; fix for 4.1
-	if (aoi.speakers == SPEAKERS_4POINT1)
-		context->channel_layout = av_get_channel_layout("4.1");
-#else
 	av_channel_layout_default(&context->ch_layout, channels);
 	if (aoi.speakers == SPEAKERS_4POINT1)
 		context->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_4POINT1;
-#endif
 
 	context->sample_fmt = AV_SAMPLE_FMT_S16;
 	context->frame_size = data->config.frame_size;
@@ -662,13 +634,8 @@ bool ffmpeg_mpegts_data_init(struct ffmpeg_output *stream,
 
 	avformat_network_init();
 
-#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(59, 0, 100)
-	AVOutputFormat *output_format;
-#else
-	const AVOutputFormat *output_format;
-#endif
-
-	output_format = av_guess_format("mpegts", NULL, "video/M2PT");
+	const AVOutputFormat *output_format =
+		av_guess_format("mpegts", NULL, "video/M2PT");
 
 	if (output_format == NULL) {
 		ffmpeg_mpegts_log_error(LOG_WARNING, data,

plugins/obs-ffmpeg/obs-ffmpeg-output.c

@@ -248,17 +248,11 @@ static bool create_video_stream(struct ffmpeg_data *data)
 			av_content_light_metadata_alloc(&content_size);
 		content->MaxCLL = hdr_nominal_peak_level;
 		content->MaxFALL = hdr_nominal_peak_level;
-#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(60, 31, 102)
-		av_stream_add_side_data(data->video,
-					AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
-					(uint8_t *)content, content_size);
-#else
 		av_packet_side_data_add(
 			&data->video->codecpar->coded_side_data,
 			&data->video->codecpar->nb_coded_side_data,
 			AV_PKT_DATA_CONTENT_LIGHT_LEVEL, (uint8_t *)content,
 			content_size, 0);
-#endif
 
 		AVMasteringDisplayMetadata *const mastering =
 			av_mastering_display_metadata_alloc();
@@ -274,18 +268,11 @@ static bool create_video_stream(struct ffmpeg_data *data)
 		mastering->max_luminance = av_make_q(hdr_nominal_peak_level, 1);
 		mastering->has_primaries = 1;
 		mastering->has_luminance = 1;
-#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(60, 31, 102)
-		av_stream_add_side_data(data->video,
-					AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
-					(uint8_t *)mastering,
-					sizeof(*mastering));
-#else
 		av_packet_side_data_add(
 			&data->video->codecpar->coded_side_data,
 			&data->video->codecpar->nb_coded_side_data,
 			AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
 			(uint8_t *)mastering, sizeof(*mastering), 0);
-#endif
 	}
 
 	if (context->pix_fmt != data->config.format ||
@@ -319,14 +306,8 @@ static bool open_audio_codec(struct ffmpeg_data *data, int idx)
 	}
 
 	data->aframe[idx]->format = context->sample_fmt;
-#if LIBAVUTIL_VERSION_INT < AV_VERSION_INT(57, 24, 100)
-	data->aframe[idx]->channels = context->channels;
-	data->aframe[idx]->channel_layout = context->channel_layout;
-	channels = context->channels;
-#else
 	data->aframe[idx]->ch_layout = context->ch_layout;
 	channels = context->ch_layout.nb_channels;
-#endif
 	data->aframe[idx]->sample_rate = context->sample_rate;
 	context->strict_std_compliance = -2;
 
@@ -375,23 +356,13 @@ static bool create_audio_stream(struct ffmpeg_data *data, int idx)
 	context = avcodec_alloc_context3(data->acodec);
 	context->bit_rate = (int64_t)data->config.audio_bitrate * 1000;
 	context->time_base = (AVRational){1, aoi.samples_per_sec};
-#if LIBAVUTIL_VERSION_INT < AV_VERSION_INT(57, 24, 100)
-	context->channels = get_audio_channels(aoi.speakers);
-#endif
 	channels = get_audio_channels(aoi.speakers);
 
 	context->sample_rate = aoi.samples_per_sec;
-#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(59, 24, 100)
-	context->channel_layout = av_get_default_channel_layout(channels);
-
-	//avutil default channel layout for 5 channels is 5.0 ; fix for 4.1
-	if (aoi.speakers == SPEAKERS_4POINT1)
-		context->channel_layout = av_get_channel_layout("4.1");
-#else
 	av_channel_layout_default(&context->ch_layout, channels);
 	if (aoi.speakers == SPEAKERS_4POINT1)
 		context->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_4POINT1;
-#endif
+
 	context->sample_fmt = data->acodec->sample_fmts
 				      ? data->acodec->sample_fmts[0]
 				      : AV_SAMPLE_FMT_FLTP;
@@ -565,34 +536,6 @@ static inline const char *safe_str(const char *s)
 		return s;
 }
 
-#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(59, 0, 100)
-static enum AVCodecID get_codec_id(const char *name, int id)
-{
-	const AVCodec *codec;
-
-	if (id != 0)
-		return (enum AVCodecID)id;
-
-	if (!name || !*name)
-		return AV_CODEC_ID_NONE;
-
-	codec = avcodec_find_encoder_by_name(name);
-	if (!codec)
-		return AV_CODEC_ID_NONE;
-
-	return codec->id;
-}
-
-static void set_encoder_ids(struct ffmpeg_data *data)
-{
-	data->output->oformat->video_codec = get_codec_id(
-		data->config.video_encoder, data->config.video_encoder_id);
-
-	data->output->oformat->audio_codec = get_codec_id(
-		data->config.audio_encoder, data->config.audio_encoder_id);
-}
-#endif
-
 bool ffmpeg_data_init(struct ffmpeg_data *data, struct ffmpeg_cfg *config)
 {
 	bool is_rtmp = false;
@@ -608,13 +551,7 @@ bool ffmpeg_data_init(struct ffmpeg_data *data, struct ffmpeg_cfg *config)
 
 	is_rtmp = (astrcmpi_n(config->url, "rtmp://", 7) == 0);
 
-#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(59, 0, 100)
-	AVOutputFormat *output_format;
-#else
-	const AVOutputFormat *output_format;
-#endif
-
-	output_format = av_guess_format(
+	const AVOutputFormat *output_format = av_guess_format(
 		is_rtmp ? "flv" : data->config.format_name, data->config.url,
 		is_rtmp ? NULL : data->config.format_mime_type);
 
@@ -640,20 +577,10 @@ bool ffmpeg_data_init(struct ffmpeg_data *data, struct ffmpeg_cfg *config)
 		goto fail;
 	}
 
-#if LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(59, 0, 100)
-	if (is_rtmp) {
-		data->output->oformat->video_codec = AV_CODEC_ID_H264;
-		data->output->oformat->audio_codec = AV_CODEC_ID_AAC;
-	} else {
-		if (data->config.format_name)
-			set_encoder_ids(data);
-	}
-#else
 	if (is_rtmp) {
 		data->config.audio_encoder_id = AV_CODEC_ID_AAC;
 		data->config.video_encoder_id = AV_CODEC_ID_H264;
 	}
-#endif
 
 	if (!init_streams(data))
 		goto fail;
@@ -856,12 +783,7 @@ static void encode_audio(struct ffmpeg_output *output, int idx,
 
 	AVPacket *packet = NULL;
 	int ret, got_packet;
-	int channels;
-#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(57, 24, 100)
-	channels = context->ch_layout.nb_channels;
-#else
-	channels = context->channels;
-#endif
+	int channels = context->ch_layout.nb_channels;
 	size_t total_size = data->frame_size * block_size * channels;
 
 	data->aframe[idx]->nb_samples = data->frame_size;