On Thu, 12 Feb 2026 11:56:02 +0100 Sebastian Ramacher wrote:
On 2026-02-07 13:02:24 +0100, Helmut Grohne wrote:
> Hi,
>
> TL;DR: Upgrade to kodi 22.x and drop libpostproc-dev from B-D.Alternate proposal:
backport a few upstream commits to kodi 21.3 & drop libpostproc from B-D
I'm not coming empty handed: you will find in attachement 3 patches that
you can drop in the d/patches directory that will make version 21.3+dfsg
build against FFmpeg 8 (once libpostproc-dev has been removed from B-D)
I have only tested this build with a few sample of very "classic" files,
like H264 or H265 video with AC3 audio, but "it works for me" ©®™
Cheers,
Sébastien
Description: make use of internal FFmpeg CPU capabilities detection for video post-processing
Origin: https://github.com/xbmc/xbmc/pull/26471
--- a/xbmc/cores/FFmpeg.h
+++ b/xbmc/cores/FFmpeg.h
@@ -9,7 +9,6 @@
#pragma once
#include "ServiceBroker.h"
-#include "utils/CPUInfo.h"
#include "utils/StringUtils.h"
extern "C" {
@@ -42,23 +41,6 @@
} // namespace FFMPEG_HELP_TOOLS
-inline int PPCPUFlags()
-{
- unsigned int cpuFeatures = CServiceBroker::GetCPUInfo()->GetCPUFeatures();
- int flags = 0;
-
- if (cpuFeatures & CPU_FEATURE_MMX)
- flags |= PP_CPU_CAPS_MMX;
- if (cpuFeatures & CPU_FEATURE_MMX2)
- flags |= PP_CPU_CAPS_MMX2;
- if (cpuFeatures & CPU_FEATURE_3DNOW)
- flags |= PP_CPU_CAPS_3DNOW;
- if (cpuFeatures & CPU_FEATURE_ALTIVEC)
- flags |= PP_CPU_CAPS_ALTIVEC;
-
- return flags;
-}
-
// callback used for logging
void ff_avutil_log(void* ptr, int level, const char* format, va_list va);
void ff_flush_avutil_log_buffers(void);
--- a/xbmc/cores/VideoPlayer/DVDCodecs/Video/DVDVideoPPFFmpeg.cpp
+++ b/xbmc/cores/VideoPlayer/DVDCodecs/Video/DVDVideoPPFFmpeg.cpp
@@ -54,7 +54,7 @@ bool CDVDVideoPPFFmpeg::CheckInit(int iWidth, int iHeight)
Dispose();
}
- m_pContext = pp_get_context(iWidth, iHeight, PPCPUFlags() | PP_FORMAT_420);
+ m_pContext = pp_get_context(iWidth, iHeight, PP_CPU_CAPS_AUTO | PP_FORMAT_420);
m_iInitWidth = iWidth;
m_iInitHeight = iHeight;
Description: Use AV_PROFILE_* instead of the deprecated FF_PROFILE_*
Origin: https://github.com/xbmc/xbmc/pull/26996
--- a/xbmc/cores/VideoPlayer/DVDDemuxers/DVDDemuxFFmpeg.cpp
+++ b/xbmc/cores/VideoPlayer/DVDDemuxers/DVDDemuxFFmpeg.cpp
@@ -2053,9 +2053,9 @@ std::string CDVDDemuxFFmpeg::GetStreamCo
/* use profile to determine the DTS type */
if (stream->codec == AV_CODEC_ID_DTS)
{
- if (stream->profile == FF_PROFILE_DTS_HD_MA)
+ if (stream->profile == AV_PROFILE_DTS_HD_MA)
strName = "dtshd_ma";
- else if (stream->profile == FF_PROFILE_DTS_HD_HRA)
+ else if (stream->profile == AV_PROFILE_DTS_HD_HRA)
strName = "dtshd_hra";
else
strName = "dca";
--- a/xbmc/cores/VideoPlayer/AudioSinkAE.cpp
+++ b/xbmc/cores/VideoPlayer/AudioSinkAE.cpp
@@ -19,6 +19,11 @@
#include <mutex>
+extern "C"
+{
+#include <libavcodec/defs.h>
+}
+
using namespace std::chrono_literals;
CAudioSinkAE::CAudioSinkAE(CDVDClock *clock) : m_pClock(clock)
@@ -353,9 +358,9 @@ CAEStreamInfo::DataType CAudioSinkAE::Ge
break;
case AV_CODEC_ID_DTS:
- if (profile == FF_PROFILE_DTS_HD_HRA)
+ if (profile == AV_PROFILE_DTS_HD_HRA)
format.m_streamInfo.m_type = CAEStreamInfo::STREAM_TYPE_DTSHD;
- else if (profile == FF_PROFILE_DTS_HD_MA)
+ else if (profile == AV_PROFILE_DTS_HD_MA)
format.m_streamInfo.m_type = CAEStreamInfo::STREAM_TYPE_DTSHD_MA;
else
format.m_streamInfo.m_type = CAEStreamInfo::STREAM_TYPE_DTSHD_CORE;
--- a/xbmc/cores/VideoPlayer/DVDCodecs/Video/AddonVideoCodec.cpp
+++ b/xbmc/cores/VideoPlayer/DVDCodecs/Video/AddonVideoCodec.cpp
@@ -16,6 +16,11 @@
#include "cores/VideoPlayer/Interface/TimingConstants.h"
#include "utils/log.h"
+extern "C"
+{
+#include <libavcodec/defs.h>
+}
+
namespace
{
AVPixelFormat ConvertToPixelFormat(const VIDEOCODEC_FORMAT videoFormat)
@@ -127,33 +132,33 @@ bool CAddonVideoCodec::CopyToInitData(VI
initData.codec = VIDEOCODEC_H264;
switch (hints.profile)
{
- case 0:
- case FF_PROFILE_UNKNOWN:
- initData.codecProfile = STREAMCODEC_PROFILE::CodecProfileUnknown;
- break;
- case FF_PROFILE_H264_BASELINE:
- initData.codecProfile = STREAMCODEC_PROFILE::H264CodecProfileBaseline;
- break;
- case FF_PROFILE_H264_MAIN:
- initData.codecProfile = STREAMCODEC_PROFILE::H264CodecProfileMain;
- break;
- case FF_PROFILE_H264_EXTENDED:
- initData.codecProfile = STREAMCODEC_PROFILE::H264CodecProfileExtended;
- break;
- case FF_PROFILE_H264_HIGH:
- initData.codecProfile = STREAMCODEC_PROFILE::H264CodecProfileHigh;
- break;
- case FF_PROFILE_H264_HIGH_10:
- initData.codecProfile = STREAMCODEC_PROFILE::H264CodecProfileHigh10;
- break;
- case FF_PROFILE_H264_HIGH_422:
- initData.codecProfile = STREAMCODEC_PROFILE::H264CodecProfileHigh422;
- break;
- case FF_PROFILE_H264_HIGH_444_PREDICTIVE:
- initData.codecProfile = STREAMCODEC_PROFILE::H264CodecProfileHigh444Predictive;
- break;
- default:
- return false;
+ case 0:
+ case AV_PROFILE_UNKNOWN:
+ initData.codecProfile = STREAMCODEC_PROFILE::CodecProfileUnknown;
+ break;
+ case AV_PROFILE_H264_BASELINE:
+ initData.codecProfile = STREAMCODEC_PROFILE::H264CodecProfileBaseline;
+ break;
+ case AV_PROFILE_H264_MAIN:
+ initData.codecProfile = STREAMCODEC_PROFILE::H264CodecProfileMain;
+ break;
+ case AV_PROFILE_H264_EXTENDED:
+ initData.codecProfile = STREAMCODEC_PROFILE::H264CodecProfileExtended;
+ break;
+ case AV_PROFILE_H264_HIGH:
+ initData.codecProfile = STREAMCODEC_PROFILE::H264CodecProfileHigh;
+ break;
+ case AV_PROFILE_H264_HIGH_10:
+ initData.codecProfile = STREAMCODEC_PROFILE::H264CodecProfileHigh10;
+ break;
+ case AV_PROFILE_H264_HIGH_422:
+ initData.codecProfile = STREAMCODEC_PROFILE::H264CodecProfileHigh422;
+ break;
+ case AV_PROFILE_H264_HIGH_444_PREDICTIVE:
+ initData.codecProfile = STREAMCODEC_PROFILE::H264CodecProfileHigh444Predictive;
+ break;
+ default:
+ return false;
}
break;
case AV_CODEC_ID_VP8:
@@ -163,43 +168,43 @@ bool CAddonVideoCodec::CopyToInitData(VI
initData.codec = VIDEOCODEC_VP9;
switch (hints.profile)
{
- case FF_PROFILE_UNKNOWN:
- initData.codecProfile = STREAMCODEC_PROFILE::CodecProfileUnknown;
- break;
- case FF_PROFILE_VP9_0:
- initData.codecProfile = STREAMCODEC_PROFILE::VP9CodecProfile0;
- break;
- case FF_PROFILE_VP9_1:
- initData.codecProfile = STREAMCODEC_PROFILE::VP9CodecProfile1;
- break;
- case FF_PROFILE_VP9_2:
- initData.codecProfile = STREAMCODEC_PROFILE::VP9CodecProfile2;
- break;
- case FF_PROFILE_VP9_3:
- initData.codecProfile = STREAMCODEC_PROFILE::VP9CodecProfile3;
- break;
- default:
- return false;
+ case AV_PROFILE_UNKNOWN:
+ initData.codecProfile = STREAMCODEC_PROFILE::CodecProfileUnknown;
+ break;
+ case AV_PROFILE_VP9_0:
+ initData.codecProfile = STREAMCODEC_PROFILE::VP9CodecProfile0;
+ break;
+ case AV_PROFILE_VP9_1:
+ initData.codecProfile = STREAMCODEC_PROFILE::VP9CodecProfile1;
+ break;
+ case AV_PROFILE_VP9_2:
+ initData.codecProfile = STREAMCODEC_PROFILE::VP9CodecProfile2;
+ break;
+ case AV_PROFILE_VP9_3:
+ initData.codecProfile = STREAMCODEC_PROFILE::VP9CodecProfile3;
+ break;
+ default:
+ return false;
}
break;
case AV_CODEC_ID_AV1:
initData.codec = VIDEOCODEC_AV1;
switch (hints.profile)
{
- case FF_PROFILE_UNKNOWN:
- initData.codecProfile = STREAMCODEC_PROFILE::CodecProfileUnknown;
- break;
- case FF_PROFILE_AV1_MAIN:
- initData.codecProfile = STREAMCODEC_PROFILE::AV1CodecProfileMain;
- break;
- case FF_PROFILE_AV1_HIGH:
- initData.codecProfile = STREAMCODEC_PROFILE::AV1CodecProfileHigh;
- break;
- case FF_PROFILE_AV1_PROFESSIONAL:
- initData.codecProfile = STREAMCODEC_PROFILE::AV1CodecProfileProfessional;
- break;
- default:
- return false;
+ case AV_PROFILE_UNKNOWN:
+ initData.codecProfile = STREAMCODEC_PROFILE::CodecProfileUnknown;
+ break;
+ case AV_PROFILE_AV1_MAIN:
+ initData.codecProfile = STREAMCODEC_PROFILE::AV1CodecProfileMain;
+ break;
+ case AV_PROFILE_AV1_HIGH:
+ initData.codecProfile = STREAMCODEC_PROFILE::AV1CodecProfileHigh;
+ break;
+ case AV_PROFILE_AV1_PROFESSIONAL:
+ initData.codecProfile = STREAMCODEC_PROFILE::AV1CodecProfileProfessional;
+ break;
+ default:
+ return false;
}
break;
default:
--- a/xbmc/cores/VideoPlayer/DVDCodecs/Video/DVDVideoCodecFFmpeg.cpp
+++ b/xbmc/cores/VideoPlayer/DVDCodecs/Video/DVDVideoCodecFFmpeg.cpp
@@ -31,6 +31,7 @@
#include <mutex>
extern "C" {
+#include <libavcodec/defs.h>
#include <libavfilter/avfilter.h>
#include <libavfilter/buffersink.h>
#include <libavfilter/buffersrc.h>
@@ -260,8 +261,8 @@ enum AVPixelFormat CDVDVideoCodecFFmpeg:
// 2nd condition:
// fix an ffmpeg issue here, it calls us with an invalid profile
// then a 2nd call with a valid one
- if(ctx->m_decoderState != STATE_HW_SINGLE ||
- (avctx->codec_id == AV_CODEC_ID_VC1 && avctx->profile == FF_PROFILE_UNKNOWN))
+ if (ctx->m_decoderState != STATE_HW_SINGLE ||
+ (avctx->codec_id == AV_CODEC_ID_VC1 && avctx->profile == AV_PROFILE_UNKNOWN))
{
AVPixelFormat defaultFmt = avcodec_default_get_format(avctx, fmt);
pixFmtName = av_get_pix_fmt_name(defaultFmt);
@@ -1047,11 +1048,11 @@ bool CDVDVideoCodecFFmpeg::GetPictureCom
else if (m_pCodecContext->pix_fmt == AV_PIX_FMT_YUV420P10)
pVideoPicture->colorBits = 10;
else if (m_pCodecContext->codec_id == AV_CODEC_ID_HEVC &&
- m_pCodecContext->profile == FF_PROFILE_HEVC_MAIN_10)
+ m_pCodecContext->profile == AV_PROFILE_HEVC_MAIN_10)
pVideoPicture->colorBits = 10;
else if (m_pCodecContext->codec_id == AV_CODEC_ID_H264 &&
- (m_pCodecContext->profile == FF_PROFILE_H264_HIGH_10||
- m_pCodecContext->profile == FF_PROFILE_H264_HIGH_10_INTRA))
+ (m_pCodecContext->profile == AV_PROFILE_H264_HIGH_10 ||
+ m_pCodecContext->profile == AV_PROFILE_H264_HIGH_10_INTRA))
pVideoPicture->colorBits = 10;
else if ((m_pCodecContext->codec_id == AV_CODEC_ID_VP9 ||
m_pCodecContext->codec_id == AV_CODEC_ID_AV1) &&
--- a/xbmc/cores/VideoPlayer/DVDCodecs/Video/DXVA.cpp
+++ b/xbmc/cores/VideoPlayer/DVDCodecs/Video/DXVA.cpp
@@ -37,6 +37,11 @@
#include <initguid.h>
#include <sdkddkver.h>
+extern "C"
+{
+#include <libavcodec/defs.h>
+}
+
using namespace DXVA;
using namespace Microsoft::WRL;
using namespace std::chrono_literals;
@@ -65,20 +70,20 @@ DEFINE_GUID(DXVA_NoEncrypt, 0x1b81beD0,
namespace
{
-constexpr int PROFILES_MPEG2_SIMPLE[] = {FF_PROFILE_MPEG2_SIMPLE, FF_PROFILE_UNKNOWN};
-constexpr int PROFILES_MPEG2_MAIN[] = {FF_PROFILE_MPEG2_SIMPLE, FF_PROFILE_MPEG2_MAIN,
- FF_PROFILE_UNKNOWN};
-constexpr int PROFILES_H264_HIGH[] = {FF_PROFILE_H264_BASELINE,
- FF_PROFILE_H264_CONSTRAINED_BASELINE, FF_PROFILE_H264_MAIN,
- FF_PROFILE_H264_HIGH, FF_PROFILE_UNKNOWN};
-constexpr int PROFILES_HEVC_MAIN[] = {FF_PROFILE_HEVC_MAIN, FF_PROFILE_UNKNOWN};
-constexpr int PROFILES_HEVC_MAIN10[] = {FF_PROFILE_HEVC_MAIN, FF_PROFILE_HEVC_MAIN_10,
- FF_PROFILE_UNKNOWN};
-constexpr int PROFILES_VP9_0[] = {FF_PROFILE_VP9_0, FF_PROFILE_UNKNOWN};
-constexpr int PROFILES_VP9_10_2[] = {FF_PROFILE_VP9_2, FF_PROFILE_UNKNOWN};
-constexpr int PROFILES_AV1_MAIN[] = {FF_PROFILE_AV1_MAIN, FF_PROFILE_UNKNOWN};
-constexpr int PROFILES_AV1_HIGH[] = {FF_PROFILE_AV1_HIGH, FF_PROFILE_UNKNOWN};
-constexpr int PROFILES_AV1_PROFESSIONAL[] = {FF_PROFILE_AV1_PROFESSIONAL, FF_PROFILE_UNKNOWN};
+constexpr int PROFILES_MPEG2_SIMPLE[] = {AV_PROFILE_MPEG2_SIMPLE, AV_PROFILE_UNKNOWN};
+constexpr int PROFILES_MPEG2_MAIN[] = {AV_PROFILE_MPEG2_SIMPLE, AV_PROFILE_MPEG2_MAIN,
+ AV_PROFILE_UNKNOWN};
+constexpr int PROFILES_H264_HIGH[] = {AV_PROFILE_H264_BASELINE,
+ AV_PROFILE_H264_CONSTRAINED_BASELINE, AV_PROFILE_H264_MAIN,
+ AV_PROFILE_H264_HIGH, AV_PROFILE_UNKNOWN};
+constexpr int PROFILES_HEVC_MAIN[] = {AV_PROFILE_HEVC_MAIN, AV_PROFILE_UNKNOWN};
+constexpr int PROFILES_HEVC_MAIN10[] = {AV_PROFILE_HEVC_MAIN, AV_PROFILE_HEVC_MAIN_10,
+ AV_PROFILE_UNKNOWN};
+constexpr int PROFILES_VP9_0[] = {AV_PROFILE_VP9_0, AV_PROFILE_UNKNOWN};
+constexpr int PROFILES_VP9_10_2[] = {AV_PROFILE_VP9_2, AV_PROFILE_UNKNOWN};
+constexpr int PROFILES_AV1_MAIN[] = {AV_PROFILE_AV1_MAIN, AV_PROFILE_UNKNOWN};
+constexpr int PROFILES_AV1_HIGH[] = {AV_PROFILE_AV1_HIGH, AV_PROFILE_UNKNOWN};
+constexpr int PROFILES_AV1_PROFESSIONAL[] = {AV_PROFILE_AV1_PROFESSIONAL, AV_PROFILE_UNKNOWN};
} // namespace
typedef struct
@@ -460,10 +465,10 @@ bool CContext::GetFormatAndConfig(AVCode
supported = false;
if (mode.profiles == nullptr)
supported = true;
- else if (avctx->profile == FF_PROFILE_UNKNOWN)
+ else if (avctx->profile == AV_PROFILE_UNKNOWN)
supported = true;
else
- for (const int* pProfile = &mode.profiles[0]; *pProfile != FF_PROFILE_UNKNOWN; ++pProfile)
+ for (const int* pProfile = &mode.profiles[0]; *pProfile != AV_PROFILE_UNKNOWN; ++pProfile)
{
if (*pProfile == avctx->profile)
{
@@ -482,9 +487,9 @@ bool CContext::GetFormatAndConfig(AVCode
{
bool bHighBits =
(avctx->codec_id == AV_CODEC_ID_HEVC && (avctx->sw_pix_fmt == AV_PIX_FMT_YUV420P10 ||
- avctx->profile == FF_PROFILE_HEVC_MAIN_10)) ||
+ avctx->profile == AV_PROFILE_HEVC_MAIN_10)) ||
(avctx->codec_id == AV_CODEC_ID_VP9 &&
- (avctx->sw_pix_fmt == AV_PIX_FMT_YUV420P10 || avctx->profile == FF_PROFILE_VP9_2)) ||
+ (avctx->sw_pix_fmt == AV_PIX_FMT_YUV420P10 || avctx->profile == AV_PROFILE_VP9_2)) ||
(avctx->codec_id == AV_CODEC_ID_AV1 && avctx->sw_pix_fmt == AV_PIX_FMT_YUV420P10);
if (bHighBits && render_targets_dxgi[j] < DXGI_FORMAT_P010)
--- a/xbmc/cores/VideoPlayer/DVDDemuxers/DVDDemux.cpp
+++ b/xbmc/cores/VideoPlayer/DVDDemuxers/DVDDemux.cpp
@@ -23,7 +23,7 @@ std::string CDemuxStreamAudio::GetStream
break;
case AV_CODEC_ID_EAC3:
{
- if (profile == FF_PROFILE_EAC3_DDP_ATMOS)
+ if (profile == AV_PROFILE_EAC3_DDP_ATMOS)
strInfo = "DD+ ATMOS ";
else
strInfo = "DD+ ";
@@ -33,25 +33,25 @@ std::string CDemuxStreamAudio::GetStream
{
switch (profile)
{
- case FF_PROFILE_DTS_96_24:
+ case AV_PROFILE_DTS_96_24:
strInfo = "DTS 96/24 ";
break;
- case FF_PROFILE_DTS_ES:
+ case AV_PROFILE_DTS_ES:
strInfo = "DTS ES ";
break;
- case FF_PROFILE_DTS_EXPRESS:
+ case AV_PROFILE_DTS_EXPRESS:
strInfo = "DTS EXPRESS ";
break;
- case FF_PROFILE_DTS_HD_MA:
+ case AV_PROFILE_DTS_HD_MA:
strInfo = "DTS-HD MA ";
break;
- case FF_PROFILE_DTS_HD_HRA:
+ case AV_PROFILE_DTS_HD_HRA:
strInfo = "DTS-HD HRA ";
break;
- case FF_PROFILE_DTS_HD_MA_X:
+ case AV_PROFILE_DTS_HD_MA_X:
strInfo = "DTS-HD MA X ";
break;
- case FF_PROFILE_DTS_HD_MA_X_IMAX:
+ case AV_PROFILE_DTS_HD_MA_X_IMAX:
strInfo = "DTS-HD MA X (IMAX) ";
break;
default:
@@ -67,7 +67,7 @@ std::string CDemuxStreamAudio::GetStream
strInfo = "MP3 ";
break;
case AV_CODEC_ID_TRUEHD:
- if (profile == FF_PROFILE_TRUEHD_ATMOS)
+ if (profile == AV_PROFILE_TRUEHD_ATMOS)
strInfo = "TrueHD ATMOS ";
else
strInfo = "TrueHD ";
@@ -76,21 +76,21 @@ std::string CDemuxStreamAudio::GetStream
{
switch (profile)
{
- case FF_PROFILE_AAC_LOW:
- case FF_PROFILE_MPEG2_AAC_LOW:
+ case AV_PROFILE_AAC_LOW:
+ case AV_PROFILE_MPEG2_AAC_LOW:
strInfo = "AAC-LC ";
break;
- case FF_PROFILE_AAC_HE:
- case FF_PROFILE_MPEG2_AAC_HE:
+ case AV_PROFILE_AAC_HE:
+ case AV_PROFILE_MPEG2_AAC_HE:
strInfo = "HE-AAC ";
break;
- case FF_PROFILE_AAC_HE_V2:
+ case AV_PROFILE_AAC_HE_V2:
strInfo = "HE-AACv2 ";
break;
- case FF_PROFILE_AAC_SSR:
+ case AV_PROFILE_AAC_SSR:
strInfo = "AAC-SSR ";
break;
- case FF_PROFILE_AAC_LTP:
+ case AV_PROFILE_AAC_LTP:
strInfo = "AAC-LTP ";
break;
default:
--- a/xbmc/cores/VideoPlayer/DVDDemuxers/DVDDemux.h
+++ b/xbmc/cores/VideoPlayer/DVDDemuxers/DVDDemux.h
@@ -33,6 +33,7 @@ class IAddonProvider;
extern "C"
{
#include <libavcodec/avcodec.h>
+#include <libavcodec/defs.h>
#include <libavutil/dovi_meta.h>
#include <libavutil/mastering_display_metadata.h>
}
@@ -78,8 +79,8 @@ public:
dvdNavId = 0;
demuxerId = -1;
codec_fourcc = 0;
- profile = FF_PROFILE_UNKNOWN;
- level = FF_LEVEL_UNKNOWN;
+ profile = AV_PROFILE_UNKNOWN;
+ level = AV_LEVEL_UNKNOWN;
type = STREAM_NONE;
source = STREAM_SOURCE_NONE;
iDuration = 0;
--- a/xbmc/cores/VideoPlayer/DVDDemuxers/DVDDemuxClient.cpp
+++ b/xbmc/cores/VideoPlayer/DVDDemuxers/DVDDemuxClient.cpp
@@ -19,6 +19,11 @@
#include <type_traits>
#include <utility>
+extern "C"
+{
+#include <libavcodec/defs.h>
+}
+
class CDemuxStreamClientInternal
{
public:
@@ -206,7 +211,7 @@ bool CDVDDemuxClient::ParsePacket(DemuxP
if (len >= 0)
{
if (stream->m_context->profile != st->profile &&
- stream->m_context->profile != FF_PROFILE_UNKNOWN)
+ stream->m_context->profile != AV_PROFILE_UNKNOWN)
{
CLog::Log(LOGDEBUG, "CDVDDemuxClient::ParsePacket - ({}) profile changed from {} to {}", st->uniqueId, st->profile, stream->m_context->profile);
st->profile = stream->m_context->profile;
@@ -214,8 +219,7 @@ bool CDVDDemuxClient::ParsePacket(DemuxP
st->disabled = false;
}
- if (stream->m_context->level != st->level &&
- stream->m_context->level != FF_LEVEL_UNKNOWN)
+ if (stream->m_context->level != st->level && stream->m_context->level != AV_LEVEL_UNKNOWN)
{
CLog::Log(LOGDEBUG, "CDVDDemuxClient::ParsePacket - ({}) level changed from {} to {}", st->uniqueId, st->level, stream->m_context->level);
st->level = stream->m_context->level;
--- a/xbmc/cores/VideoPlayer/DVDInputStreams/InputStreamAddon.cpp
+++ b/xbmc/cores/VideoPlayer/DVDInputStreams/InputStreamAddon.cpp
@@ -26,6 +26,11 @@
#include <memory>
+extern "C"
+{
+#include <libavcodec/defs.h>
+}
+
CInputStreamProvider::CInputStreamProvider(const ADDON::AddonInfoPtr& addonInfo,
KODI_HANDLE parentInstance)
: m_addonInfo(addonInfo), m_parentInstance(parentInstance)
@@ -693,35 +698,35 @@ int CInputStreamAddon::ConvertVideoCodec
switch (profile)
{
case H264CodecProfileBaseline:
- return FF_PROFILE_H264_BASELINE;
+ return AV_PROFILE_H264_BASELINE;
case H264CodecProfileMain:
- return FF_PROFILE_H264_MAIN;
+ return AV_PROFILE_H264_MAIN;
case H264CodecProfileExtended:
- return FF_PROFILE_H264_EXTENDED;
+ return AV_PROFILE_H264_EXTENDED;
case H264CodecProfileHigh:
- return FF_PROFILE_H264_HIGH;
+ return AV_PROFILE_H264_HIGH;
case H264CodecProfileHigh10:
- return FF_PROFILE_H264_HIGH_10;
+ return AV_PROFILE_H264_HIGH_10;
case H264CodecProfileHigh422:
- return FF_PROFILE_H264_HIGH_422;
+ return AV_PROFILE_H264_HIGH_422;
case H264CodecProfileHigh444Predictive:
- return FF_PROFILE_H264_HIGH_444_PREDICTIVE;
+ return AV_PROFILE_H264_HIGH_444_PREDICTIVE;
case VP9CodecProfile0:
- return FF_PROFILE_VP9_0;
+ return AV_PROFILE_VP9_0;
case VP9CodecProfile1:
- return FF_PROFILE_VP9_1;
+ return AV_PROFILE_VP9_1;
case VP9CodecProfile2:
- return FF_PROFILE_VP9_2;
+ return AV_PROFILE_VP9_2;
case VP9CodecProfile3:
- return FF_PROFILE_VP9_3;
+ return AV_PROFILE_VP9_3;
case AV1CodecProfileMain:
- return FF_PROFILE_AV1_MAIN;
+ return AV_PROFILE_AV1_MAIN;
case AV1CodecProfileHigh:
- return FF_PROFILE_AV1_HIGH;
+ return AV_PROFILE_AV1_HIGH;
case AV1CodecProfileProfessional:
- return FF_PROFILE_AV1_PROFESSIONAL;
+ return AV_PROFILE_AV1_PROFESSIONAL;
default:
- return FF_PROFILE_UNKNOWN;
+ return AV_PROFILE_UNKNOWN;
}
}
@@ -730,45 +735,45 @@ int CInputStreamAddon::ConvertAudioCodec
switch (profile)
{
case AACCodecProfileMAIN:
- return FF_PROFILE_AAC_MAIN;
+ return AV_PROFILE_AAC_MAIN;
case AACCodecProfileLOW:
- return FF_PROFILE_AAC_LOW;
+ return AV_PROFILE_AAC_LOW;
case AACCodecProfileSSR:
- return FF_PROFILE_AAC_SSR;
+ return AV_PROFILE_AAC_SSR;
case AACCodecProfileLTP:
- return FF_PROFILE_AAC_LTP;
+ return AV_PROFILE_AAC_LTP;
case AACCodecProfileHE:
- return FF_PROFILE_AAC_HE;
+ return AV_PROFILE_AAC_HE;
case AACCodecProfileHEV2:
- return FF_PROFILE_AAC_HE_V2;
+ return AV_PROFILE_AAC_HE_V2;
case AACCodecProfileLD:
- return FF_PROFILE_AAC_LD;
+ return AV_PROFILE_AAC_LD;
case AACCodecProfileELD:
- return FF_PROFILE_AAC_ELD;
+ return AV_PROFILE_AAC_ELD;
case MPEG2AACCodecProfileLOW:
- return FF_PROFILE_MPEG2_AAC_LOW;
+ return AV_PROFILE_MPEG2_AAC_LOW;
case MPEG2AACCodecProfileHE:
- return FF_PROFILE_MPEG2_AAC_HE;
+ return AV_PROFILE_MPEG2_AAC_HE;
case DTSCodecProfile:
- return FF_PROFILE_DTS;
+ return AV_PROFILE_DTS;
case DTSCodecProfileES:
- return FF_PROFILE_DTS_ES;
+ return AV_PROFILE_DTS_ES;
case DTSCodecProfile9624:
- return FF_PROFILE_DTS_96_24;
+ return AV_PROFILE_DTS_96_24;
case DTSCodecProfileHDHRA:
- return FF_PROFILE_DTS_HD_HRA;
+ return AV_PROFILE_DTS_HD_HRA;
case DTSCodecProfileHDMA:
- return FF_PROFILE_DTS_HD_MA;
+ return AV_PROFILE_DTS_HD_MA;
case DTSCodecProfileHDExpress:
- return FF_PROFILE_DTS_EXPRESS;
+ return AV_PROFILE_DTS_EXPRESS;
case DTSCodecProfileHDMAX:
- return FF_PROFILE_DTS_HD_MA_X;
+ return AV_PROFILE_DTS_HD_MA_X;
case DTSCodecProfileHDMAIMAX:
- return FF_PROFILE_DTS_HD_MA_X_IMAX;
+ return AV_PROFILE_DTS_HD_MA_X_IMAX;
case DDPlusCodecProfileAtmos:
- return FF_PROFILE_EAC3_DDP_ATMOS;
+ return AV_PROFILE_EAC3_DDP_ATMOS;
default:
- return FF_PROFILE_UNKNOWN;
+ return AV_PROFILE_UNKNOWN;
}
}
--- a/xbmc/cores/paplayer/VideoPlayerCodec.cpp
+++ b/xbmc/cores/paplayer/VideoPlayerCodec.cpp
@@ -22,6 +22,11 @@
#include "utils/StringUtils.h"
#include "utils/log.h"
+extern "C"
+{
+#include <libavcodec/defs.h>
+}
+
VideoPlayerCodec::VideoPlayerCodec() : m_processInfo(CProcessInfo::CreateInstance())
{
m_CodecName = "VideoPlayer";
@@ -497,9 +502,9 @@ CAEStreamInfo::DataType VideoPlayerCodec
break;
case AV_CODEC_ID_DTS:
- if (profile == FF_PROFILE_DTS_HD_HRA)
+ if (profile == AV_PROFILE_DTS_HD_HRA)
format.m_streamInfo.m_type = CAEStreamInfo::STREAM_TYPE_DTSHD;
- else if (profile == FF_PROFILE_DTS_HD_MA)
+ else if (profile == AV_PROFILE_DTS_HD_MA)
format.m_streamInfo.m_type = CAEStreamInfo::STREAM_TYPE_DTSHD_MA;
else
format.m_streamInfo.m_type = CAEStreamInfo::STREAM_TYPE_DTSHD_CORE;
Description: Update to ffmpeg 8.0
Origin: https://github.com/xbmc/xbmc/pull/27149
--- a/cmake/modules/FindFFMPEG.cmake
+++ b/cmake/modules/FindFFMPEG.cmake
@@ -192,13 +192,14 @@ else()
libavformat${_avformat_ver}
libavutil${_avutil_ver}
libswscale${_swscale_ver}
- libswresample${_swresample_ver}
- libpostproc${_postproc_ver})
+ libswresample${_swresample_ver})
if(NOT WIN32)
find_package(PkgConfig REQUIRED)
- pkg_check_modules(PC_FFMPEG ${FFMPEG_PKGS})
+ # explicitly set quiet, as another search that has output is run anyway
+ pkg_check_modules(PC_FFMPEG ${FFMPEG_PKGS} QUIET)
+ pkg_check_modules(PC_FFMPEGPOSTPROC libpostproc${_postproc_ver} QUIET)
endif()
if((PC_FFMPEG_FOUND
@@ -207,8 +208,7 @@ else()
AND PC_FFMPEG_libavformat_VERSION
AND PC_FFMPEG_libavutil_VERSION
AND PC_FFMPEG_libswscale_VERSION
- AND PC_FFMPEG_libswresample_VERSION
- AND PC_FFMPEG_libpostproc_VERSION)
+ AND PC_FFMPEG_libswresample_VERSION)
OR WIN32)
set(FFMPEG_VERSION ${REQUIRED_FFMPEG_VERSION})
@@ -226,7 +226,7 @@ else()
endmacro()
find_path(FFMPEG_INCLUDE_DIRS libavcodec/avcodec.h libavfilter/avfilter.h libavformat/avformat.h
- libavutil/avutil.h libswscale/swscale.h libpostproc/postprocess.h
+ libavutil/avutil.h libswscale/swscale.h
PATH_SUFFIXES ffmpeg
HINTS ${DEPENDS_PATH}/include
${${CORE_PLATFORM_LC}_SEARCH_CONFIG})
@@ -236,6 +236,12 @@ else()
ffmpeg_find_lib(${_libname})
endforeach()
+ find_library(FFMPEG_LIBPOSTPROC
+ NAMES postproc
+ PATH_SUFFIXES ffmpeg/libpostproc
+ HINTS ${DEPENDS_PATH}/lib ${PC_FFMPEG_LIBPOSTPROC_LIBDIR}
+ ${${CORE_PLATFORM_LC}_SEARCH_CONFIG})
+
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(FFMPEG
VERSION_VAR FFMPEG_VERSION
@@ -246,7 +252,6 @@ else()
FFMPEG_LIBAVUTIL
FFMPEG_LIBSWSCALE
FFMPEG_LIBSWRESAMPLE
- FFMPEG_LIBPOSTPROC
FFMPEG_VERSION
FAIL_MESSAGE "FFmpeg ${REQUIRED_FFMPEG_VERSION} not found, please consider using -DENABLE_INTERNAL_FFMPEG=ON")
@@ -288,6 +293,10 @@ else()
ffmpeg_create_target(${_libname})
endforeach()
+ if (FFMPEG_LIBPOSTPROC)
+ ffmpeg_create_target(libpostproc)
+ endif()
+
else()
if(FFMPEG_PATH)
message(FATAL_ERROR "FFmpeg not found, please consider using -DENABLE_INTERNAL_FFMPEG=ON")
@@ -314,7 +323,10 @@ if(FFMPEG_FOUND)
target_link_libraries(ffmpeg::ffmpeg INTERFACE ffmpeg::libavutil)
target_link_libraries(ffmpeg::ffmpeg INTERFACE ffmpeg::libswscale)
target_link_libraries(ffmpeg::ffmpeg INTERFACE ffmpeg::libswresample)
- target_link_libraries(ffmpeg::ffmpeg INTERFACE ffmpeg::libpostproc)
+ if (TARGET ffmpeg::libpostproc)
+ set_property(TARGET ffmpeg::libpostproc APPEND PROPERTY INTERFACE_COMPILE_DEFINITIONS HAVE_LIBPOSTPROC)
+ target_link_libraries(ffmpeg::ffmpeg INTERFACE ffmpeg::libpostproc)
+ endif()
if(TARGET ffmpeg)
add_dependencies(ffmpeg::ffmpeg ffmpeg)
--- a/xbmc/cores/AudioEngine/Encoders/AEEncoderFFmpeg.cpp
+++ b/xbmc/cores/AudioEngine/Encoders/AEEncoderFFmpeg.cpp
@@ -339,15 +339,6 @@ int CAEEncoderFFmpeg::Encode(uint8_t *in
return size;
}
-int CAEEncoderFFmpeg::GetData(uint8_t **data)
-{
- int size;
- *data = m_Buffer;
- size = m_BufferSize;
- m_BufferSize = 0;
- return size;
-}
-
double CAEEncoderFFmpeg::GetDelay(unsigned int bufferSize)
{
if (!m_CodecCtx)
--- a/xbmc/cores/AudioEngine/Encoders/AEEncoderFFmpeg.h
+++ b/xbmc/cores/AudioEngine/Encoders/AEEncoderFFmpeg.h
@@ -31,8 +31,7 @@ public:
AVCodecID GetCodecID() override;
unsigned int GetFrames() override;
- int Encode(uint8_t *in, int in_size, uint8_t *out, int out_size) override;
- int GetData(uint8_t **data) override;
+ int Encode(uint8_t* in, int in_size, uint8_t* out, int out_size) override;
double GetDelay(unsigned int bufferSize) override;
private:
unsigned int BuildChannelLayout(const int64_t ffmap, CAEChannelInfo& layout);
@@ -44,7 +43,6 @@ private:
AVCodecContext *m_CodecCtx;
SwrContext *m_SwrCtx;
CAEChannelInfo m_Layout;
- uint8_t m_Buffer[8 + AV_INPUT_BUFFER_MIN_SIZE];
int m_BufferSize = 0;
int m_OutputSize = 0;
double m_OutputRatio = 0.0;
--- a/xbmc/cores/AudioEngine/Interfaces/AEEncoder.h
+++ b/xbmc/cores/AudioEngine/Interfaces/AEEncoder.h
@@ -79,13 +79,6 @@ public:
virtual int Encode (uint8_t *in, int in_size, uint8_t *out, int out_size) = 0;
/**
- * Get the encoded data
- * @param data return pointer to the buffer with the current encoded block
- * @return the size in bytes of *data
- */
- virtual int GetData(uint8_t **data) = 0;
-
- /**
* Get the delay in seconds
* @param bufferSize how much encoded data the caller has buffered to add to the delay
* @return the delay in seconds including any un-fetched encoded data
--- a/xbmc/cores/FFmpeg.h
+++ b/xbmc/cores/FFmpeg.h
@@ -12,14 +12,14 @@
#include "ServiceBroker.h"
#include "utils/StringUtils.h"
-extern "C" {
+extern "C"
+{
#include <libavcodec/avcodec.h>
+#include <libavfilter/avfilter.h>
#include <libavformat/avformat.h>
#include <libavutil/avutil.h>
-#include <libavutil/log.h>
#include <libavutil/ffversion.h>
-#include <libavfilter/avfilter.h>
-#include <libpostproc/postprocess.h>
+#include <libavutil/log.h>
}
#include <tuple>
--- a/xbmc/cores/VideoPlayer/DVDCodecs/Video/CMakeLists.txt
+++ b/xbmc/cores/VideoPlayer/DVDCodecs/Video/CMakeLists.txt
@@ -4,9 +4,10 @@ set(SOURCES AddonVideoCodec.cpp
set(HEADERS AddonVideoCodec.h
DVDVideoCodec.h
- DVDVideoCodecFFmpeg.h)
+ DVDVideoCodecFFmpeg.h
+ DVDVideoPP.h)
-if(NOT ENABLE_EXTERNAL_LIBAV)
+if(TARGET ffmpeg::libpostproc)
list(APPEND SOURCES DVDVideoPPFFmpeg.cpp)
list(APPEND HEADERS DVDVideoPPFFmpeg.h)
endif()
--- a/xbmc/cores/VideoPlayer/DVDCodecs/Video/DVDVideoCodecAndroidMediaCodec.cpp
+++ b/xbmc/cores/VideoPlayer/DVDCodecs/Video/DVDVideoCodecAndroidMediaCodec.cpp
@@ -412,16 +412,16 @@ bool CDVDVideoCodecAndroidMediaCodec::Op
case AV_CODEC_ID_VP9:
switch (m_hints.profile)
{
- case FF_PROFILE_VP9_0:
+ case AV_PROFILE_VP9_0:
profile = CJNIMediaCodecInfoCodecProfileLevel::VP9Profile0;
break;
- case FF_PROFILE_VP9_1:
+ case AV_PROFILE_VP9_1:
profile = CJNIMediaCodecInfoCodecProfileLevel::VP9Profile1;
break;
- case FF_PROFILE_VP9_2:
+ case AV_PROFILE_VP9_2:
profile = CJNIMediaCodecInfoCodecProfileLevel::VP9Profile2;
break;
- case FF_PROFILE_VP9_3:
+ case AV_PROFILE_VP9_3:
profile = CJNIMediaCodecInfoCodecProfileLevel::VP9Profile3;
break;
default:;
@@ -435,33 +435,33 @@ bool CDVDVideoCodecAndroidMediaCodec::Op
case AV_CODEC_ID_H264:
switch (m_hints.profile)
{
- case FF_PROFILE_H264_BASELINE:
+ case AV_PROFILE_H264_BASELINE:
profile = CJNIMediaCodecInfoCodecProfileLevel::AVCProfileBaseline;
break;
- case FF_PROFILE_H264_MAIN:
+ case AV_PROFILE_H264_MAIN:
profile = CJNIMediaCodecInfoCodecProfileLevel::AVCProfileMain;
break;
- case FF_PROFILE_H264_EXTENDED:
+ case AV_PROFILE_H264_EXTENDED:
profile = CJNIMediaCodecInfoCodecProfileLevel::AVCProfileExtended;
break;
- case FF_PROFILE_H264_HIGH:
+ case AV_PROFILE_H264_HIGH:
profile = CJNIMediaCodecInfoCodecProfileLevel::AVCProfileHigh;
break;
- case FF_PROFILE_H264_HIGH_10:
+ case AV_PROFILE_H264_HIGH_10:
profile = CJNIMediaCodecInfoCodecProfileLevel::AVCProfileHigh10;
break;
- case FF_PROFILE_H264_HIGH_422:
+ case AV_PROFILE_H264_HIGH_422:
profile = CJNIMediaCodecInfoCodecProfileLevel::AVCProfileHigh422;
break;
- case FF_PROFILE_H264_HIGH_444:
+ case AV_PROFILE_H264_HIGH_444:
profile = CJNIMediaCodecInfoCodecProfileLevel::AVCProfileHigh444;
break;
// All currently not supported formats
- case FF_PROFILE_H264_HIGH_10_INTRA:
- case FF_PROFILE_H264_HIGH_422_INTRA:
- 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_10_INTRA:
+ case AV_PROFILE_H264_HIGH_422_INTRA:
+ case AV_PROFILE_H264_HIGH_444_PREDICTIVE:
+ case AV_PROFILE_H264_HIGH_444_INTRA:
+ case AV_PROFILE_H264_CAVLC_444:
goto FAIL;
default:
break;
@@ -483,16 +483,16 @@ bool CDVDVideoCodecAndroidMediaCodec::Op
{
switch (m_hints.profile)
{
- case FF_PROFILE_HEVC_MAIN:
+ case AV_PROFILE_HEVC_MAIN:
profile = CJNIMediaCodecInfoCodecProfileLevel::HEVCProfileMain;
break;
- case FF_PROFILE_HEVC_MAIN_10:
+ case AV_PROFILE_HEVC_MAIN_10:
profile = CJNIMediaCodecInfoCodecProfileLevel::HEVCProfileMain10;
break;
- case FF_PROFILE_HEVC_MAIN_STILL_PICTURE:
+ case AV_PROFILE_HEVC_MAIN_STILL_PICTURE:
profile = CJNIMediaCodecInfoCodecProfileLevel::HEVCProfileMainStill;
break;
- case FF_PROFILE_HEVC_REXT:
+ case AV_PROFILE_HEVC_REXT:
// No known h/w decoder supporting Hi10P
goto FAIL;
default:
@@ -681,11 +681,11 @@ bool CDVDVideoCodecAndroidMediaCodec::Op
{
switch (m_hints.profile)
{
- case FF_PROFILE_AV1_MAIN:
+ case AV_PROFILE_AV1_MAIN:
profile = CJNIMediaCodecInfoCodecProfileLevel::AV1ProfileMain8;
break;
- case FF_PROFILE_AV1_HIGH:
- case FF_PROFILE_AV1_PROFESSIONAL:
+ case AV_PROFILE_AV1_HIGH:
+ case AV_PROFILE_AV1_PROFESSIONAL:
goto FAIL;
break;
default:
--- a/xbmc/cores/VideoPlayer/DVDCodecs/Video/DVDVideoCodecDRMPRIME.cpp
+++ b/xbmc/cores/VideoPlayer/DVDCodecs/Video/DVDVideoCodecDRMPRIME.cpp
@@ -547,11 +547,11 @@ void CDVDVideoCodecDRMPRIME::SetPictureP
pVideoPicture->colorBits = 8;
if (m_pCodecContext->codec_id == AV_CODEC_ID_HEVC &&
- m_pCodecContext->profile == FF_PROFILE_HEVC_MAIN_10)
+ m_pCodecContext->profile == AV_PROFILE_HEVC_MAIN_10)
pVideoPicture->colorBits = 10;
else if (m_pCodecContext->codec_id == AV_CODEC_ID_H264 &&
- (m_pCodecContext->profile == FF_PROFILE_H264_HIGH_10 ||
- m_pCodecContext->profile == FF_PROFILE_H264_HIGH_10_INTRA))
+ (m_pCodecContext->profile == AV_PROFILE_H264_HIGH_10 ||
+ m_pCodecContext->profile == AV_PROFILE_H264_HIGH_10_INTRA))
pVideoPicture->colorBits = 10;
pVideoPicture->hasDisplayMetadata = false;
--- a/xbmc/cores/VideoPlayer/DVDCodecs/Video/DVDVideoCodecFFmpeg.cpp
+++ b/xbmc/cores/VideoPlayer/DVDCodecs/Video/DVDVideoCodecFFmpeg.cpp
@@ -11,6 +11,9 @@
#include "DVDCodecs/DVDCodecs.h"
#include "DVDCodecs/DVDFactoryCodec.h"
#include "DVDStreamInfo.h"
+#ifdef HAVE_LIBPOSTPROC
+#include "DVDVideoPPFFmpeg.h"
+#endif
#include "ServiceBroker.h"
#include "cores/FFmpeg.h"
#include "cores/VideoPlayer/Interface/TimingConstants.h"
@@ -307,8 +310,11 @@ enum AVPixelFormat CDVDVideoCodecFFmpeg:
CDVDVideoCodecFFmpeg::CDVDVideoCodecFFmpeg(CProcessInfo& processInfo)
: CDVDVideoCodec(processInfo),
- m_videoBufferPool(std::make_shared<CVideoBufferPoolFFmpeg>()),
- m_postProc(processInfo)
+ m_videoBufferPool(std::make_shared<CVideoBufferPoolFFmpeg>())
+#ifdef HAVE_LIBPOSTPROC
+ ,
+ m_postProc(std::make_unique<CDVDVideoPPFFmpeg>(processInfo))
+#endif
{
m_decoderState = STATE_NONE;
}
@@ -335,7 +341,9 @@ bool CDVDVideoCodecFFmpeg::Open(CDVDStre
m_formats.clear();
m_formats = m_processInfo.GetPixFormats();
+#if LIBAVFILTER_BUILD < AV_VERSION_INT(10, 6, 100)
m_formats.push_back(AV_PIX_FMT_NONE); /* always add none to get a terminated list in ffmpeg world */
+#endif
m_processInfo.SetSwDeinterlacingMethods();
m_processInfo.SetVideoInterlaced(false);
@@ -916,10 +924,12 @@ bool CDVDVideoCodecFFmpeg::SetPicturePar
buffer->SetRef(m_pFrame);
pVideoPicture->videoBuffer = buffer;
- if (m_processInfo.GetVideoSettings().m_PostProcess)
+ if (m_postProc && m_processInfo.GetVideoSettings().m_PostProcess)
{
- m_postProc.SetType(CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_videoPPFFmpegPostProc, false);
- m_postProc.Process(pVideoPicture);
+ m_postProc->SetType(
+ CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_videoPPFFmpegPostProc,
+ false);
+ m_postProc->Process(pVideoPicture);
}
return true;
@@ -1179,7 +1189,7 @@ int CDVDVideoCodecFFmpeg::FilterOpen(con
return 0;
}
- if (!(m_pFilterGraph = avfilter_graph_alloc()))
+ if (!((m_pFilterGraph = avfilter_graph_alloc())))
{
CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::FilterOpen - unable to alloc filter graph");
return -1;
@@ -1196,20 +1206,29 @@ int CDVDVideoCodecFFmpeg::FilterOpen(con
m_pCodecContext->sample_aspect_ratio.num != 0 ? m_pCodecContext->sample_aspect_ratio.num : 1,
m_pCodecContext->sample_aspect_ratio.num != 0 ? m_pCodecContext->sample_aspect_ratio.den : 1);
- if ((result = avfilter_graph_create_filter(&m_pFilterIn, srcFilter, "src", args.c_str(), NULL, m_pFilterGraph)) < 0)
+ if (!((m_pFilterOut = avfilter_graph_alloc_filter(m_pFilterGraph, outFilter, "out"))))
{
- CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::FilterOpen - avfilter_graph_create_filter: src");
+ CLog::LogF(LOGERROR, "unable to alloc filter out");
+ return -1;
+ }
+
+ if ((result = av_opt_set_array(m_pFilterOut, "pixel_formats", AV_OPT_SEARCH_CHILDREN, 0,
+ m_formats.size(), AV_OPT_TYPE_PIXEL_FMT, m_formats.data())) < 0)
+ {
+ CLog::LogF(LOGERROR, "failed setting pix formats");
return result;
}
- if ((result = avfilter_graph_create_filter(&m_pFilterOut, outFilter, "out", NULL, NULL, m_pFilterGraph)) < 0)
+ if ((result = avfilter_init_str(m_pFilterOut, nullptr) < 0))
{
- CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::FilterOpen - avfilter_graph_create_filter: out");
+ CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::FilterOpen - avfilter_init_str: out");
+ avfilter_free(m_pFilterOut);
return result;
}
- if ((result = av_opt_set_int_list(m_pFilterOut, "pix_fmts", &m_formats[0], AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN)) < 0)
+ if ((result = avfilter_graph_create_filter(&m_pFilterIn, srcFilter, "src", args.c_str(), NULL,
+ m_pFilterGraph)) < 0)
{
- CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::FilterOpen - failed settings pix formats");
+ CLog::Log(LOGERROR, "CDVDVideoCodecFFmpeg::FilterOpen - avfilter_graph_create_filter: src");
return result;
}
--- a/xbmc/cores/VideoPlayer/DVDCodecs/Video/DVDVideoCodecFFmpeg.h
+++ b/xbmc/cores/VideoPlayer/DVDCodecs/Video/DVDVideoCodecFFmpeg.h
@@ -8,20 +8,22 @@
#pragma once
+#include "DVDVideoCodec.h"
+#include "DVDVideoPP.h"
#include "cores/VideoPlayer/DVDCodecs/DVDCodecs.h"
#include "cores/VideoPlayer/DVDStreamInfo.h"
-#include "DVDVideoCodec.h"
-#include "DVDVideoPPFFmpeg.h"
+
+#include <memory>
#include <string>
#include <vector>
-extern "C" {
-#include <libavfilter/avfilter.h>
+extern "C"
+{
#include <libavcodec/avcodec.h>
+#include <libavfilter/avfilter.h>
#include <libavformat/avformat.h>
#include <libavutil/avutil.h>
#include <libswscale/swscale.h>
-#include <libpostproc/postprocess.h>
}
class CVideoBufferPoolFFmpeg;
@@ -73,7 +75,7 @@ protected:
bool m_filterEof = false;
bool m_eof = false;
- CDVDVideoPPFFmpeg m_postProc;
+ std::unique_ptr<IDVDVideoPP> m_postProc;
int m_iPictureWidth = 0;
int m_iPictureHeight = 0;
--- /dev/null
+++ b/xbmc/cores/VideoPlayer/DVDCodecs/Video/DVDVideoPP.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2025 Team Kodi
+ * This file is part of Kodi - https://kodi.tv
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ * See LICENSES/README.md for more information.
+ */
+
+#pragma once
+
+#include <string>
+
+class CProcessInfo;
+struct VideoPicture;
+
+class IDVDVideoPP
+{
+public:
+ virtual ~IDVDVideoPP() = default;
+
+ virtual void SetType(const std::string& mType, bool deinterlace) = 0;
+ virtual void Process(VideoPicture* picture) = 0;
+};
--- a/xbmc/cores/VideoPlayer/DVDCodecs/Video/DVDVideoPPFFmpeg.h
+++ b/xbmc/cores/VideoPlayer/DVDCodecs/Video/DVDVideoPPFFmpeg.h
@@ -9,20 +9,26 @@
#pragma once
#include "DVDVideoCodec.h"
+#include "DVDVideoPP.h"
+
+extern "C"
+{
+#include <libpostproc/postprocess.h>
+}
#include <string>
class CProcessInfo;
-class CDVDVideoPPFFmpeg
+class CDVDVideoPPFFmpeg : public IDVDVideoPP
{
public:
explicit CDVDVideoPPFFmpeg(CProcessInfo &processInfo);
- ~CDVDVideoPPFFmpeg();
+ ~CDVDVideoPPFFmpeg() override;
- void SetType(const std::string& mType, bool deinterlace);
- void Process(VideoPicture *pPicture);
+ void SetType(const std::string& mType, bool deinterlace) override;
+ void Process(VideoPicture* picture) override;
protected:
std::string m_sType;
--- a/xbmc/cores/VideoPlayer/DVDCodecs/Video/VAAPI.cpp
+++ b/xbmc/cores/VideoPlayer/DVDCodecs/Video/VAAPI.cpp
@@ -609,7 +609,7 @@ bool CDecoder::Open(AVCodecContext* avct
break;
case AV_CODEC_ID_H264:
{
- if (avctx->profile == FF_PROFILE_H264_CONSTRAINED_BASELINE)
+ if (avctx->profile == AV_PROFILE_H264_CONSTRAINED_BASELINE)
{
profile = VAProfileH264ConstrainedBaseline;
if (!m_vaapiConfig.context->SupportsProfile(profile))
@@ -617,7 +617,7 @@ bool CDecoder::Open(AVCodecContext* avct
}
else
{
- if(avctx->profile == FF_PROFILE_H264_MAIN)
+ if (avctx->profile == AV_PROFILE_H264_MAIN)
{
profile = VAProfileH264Main;
if (m_vaapiConfig.context->SupportsProfile(profile))
@@ -631,14 +631,14 @@ bool CDecoder::Open(AVCodecContext* avct
}
case AV_CODEC_ID_HEVC:
{
- if (avctx->profile == FF_PROFILE_HEVC_MAIN_10)
+ if (avctx->profile == AV_PROFILE_HEVC_MAIN_10)
{
if (!m_capDeepColor)
return false;
profile = VAProfileHEVCMain10;
}
- else if (avctx->profile == FF_PROFILE_HEVC_MAIN)
+ else if (avctx->profile == AV_PROFILE_HEVC_MAIN)
profile = VAProfileHEVCMain;
else
profile = VAProfileNone;
@@ -655,9 +655,9 @@ bool CDecoder::Open(AVCodecContext* avct
}
case AV_CODEC_ID_VP9:
{
- if (avctx->profile == FF_PROFILE_VP9_0)
+ if (avctx->profile == AV_PROFILE_VP9_0)
profile = VAProfileVP9Profile0;
- else if (avctx->profile == FF_PROFILE_VP9_2)
+ else if (avctx->profile == AV_PROFILE_VP9_2)
profile = VAProfileVP9Profile2;
else
profile = VAProfileNone;
@@ -678,9 +678,9 @@ bool CDecoder::Open(AVCodecContext* avct
#if VA_CHECK_VERSION(1, 8, 0)
case AV_CODEC_ID_AV1:
{
- if (avctx->profile == FF_PROFILE_AV1_MAIN)
+ if (avctx->profile == AV_PROFILE_AV1_MAIN)
profile = VAProfileAV1Profile0;
- else if (avctx->profile == FF_PROFILE_AV1_HIGH)
+ else if (avctx->profile == AV_PROFILE_AV1_HIGH)
profile = VAProfileAV1Profile1;
else
profile = VAProfileNone;
@@ -2969,19 +2969,33 @@ bool CFFmpegPostproc::Init(EINTERLACEMET
return false;
}
- if (avfilter_graph_create_filter(&m_pFilterOut, outFilter, "out", NULL, NULL, m_pFilterGraph) < 0)
+ if (!((m_pFilterOut = avfilter_graph_alloc_filter(m_pFilterGraph, outFilter, "out"))))
{
- CLog::Log(LOGERROR, "CFFmpegPostproc::Init - avfilter_graph_create_filter: out");
+ CLog::LogF(LOGERROR, "unable to alloc filter out");
return false;
}
+#if LIBAVFILTER_BUILD >= AV_VERSION_INT(10, 6, 100)
+ constexpr std::array<AVPixelFormat, 1> pixFmts = {{AV_PIX_FMT_NV12}};
+ if (av_opt_set_array(m_pFilterOut, "pixel_formats", AV_OPT_SEARCH_CHILDREN, 0, pixFmts.size(),
+ AV_OPT_TYPE_PIXEL_FMT, pixFmts.data()) < 0)
+#else
enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_NV12, AV_PIX_FMT_NONE };
- if (av_opt_set_int_list(m_pFilterOut, "pix_fmts", pix_fmts, AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN) < 0)
+ if (av_opt_set_int_list(m_pFilterOut, "pix_fmts", pix_fmts, AV_PIX_FMT_NONE,
+ AV_OPT_SEARCH_CHILDREN) < 0)
+#endif
{
CLog::Log(LOGERROR, "VAAPI::CFFmpegPostproc::Init - failed settings pix formats");
return false;
}
+ if (avfilter_init_str(m_pFilterOut, nullptr) < 0)
+ {
+ CLog::LogF(LOGERROR, "failed to initialize filter out");
+ avfilter_free(m_pFilterOut);
+ return false;
+ }
+
AVFilterInOut* outputs = avfilter_inout_alloc();
AVFilterInOut* inputs = avfilter_inout_alloc();
@@ -3096,7 +3110,6 @@ bool CFFmpegPostproc::AddPicture(CVaapiD
m_pFilterFrameIn->linesize[1] = image.pitches[1];
m_pFilterFrameIn->data[2] = NULL;
m_pFilterFrameIn->data[3] = NULL;
- m_pFilterFrameIn->pkt_size = image.data_size;
CheckSuccess(vaUnmapBuffer(m_config.dpy, image.buf), "vaUnmapBuffer");
CheckSuccess(vaDestroyImage(m_config.dpy, image.image_id), "vaDestroyImage");
--- a/xbmc/cores/VideoPlayer/DVDCodecs/Video/VDPAU.cpp
+++ b/xbmc/cores/VideoPlayer/DVDCodecs/Video/VDPAU.cpp
@@ -922,7 +922,7 @@ bool CDecoder::ConfigVDPAU(AVCodecContex
}
else if (avctx->codec_id == AV_CODEC_ID_VP9)
{
- if (avctx->profile != FF_PROFILE_VP9_0)
+ if (avctx->profile != AV_PROFILE_VP9_0)
return false;
m_vdpauConfig.maxReferences = 8;
--- a/xbmc/cores/VideoPlayer/VideoPlayer.cpp
+++ b/xbmc/cores/VideoPlayer/VideoPlayer.cpp
@@ -5076,6 +5076,10 @@ bool CVideoPlayer::Supports(ESCALINGMETH
bool CVideoPlayer::Supports(ERENDERFEATURE feature) const
{
+#ifndef HAVE_LIBPOSTPROC
+ if (feature == ERENDERFEATURE::RENDERFEATURE_POSTPROCESS)
+ return false;
+#endif
return m_renderManager.Supports(feature);
}
