Packman Build Service PMBS

avidemux3.changes Changed

avidemux3.spec Changed

avidemux2-2.8.2.git20261020.tar.xz/avidemux/common/main.cpp -> avidemux2-2.8.2.git20261026.tar.xz/avidemux/common/main.cpp Changed

avidemux2-2.8.2.git20261020.tar.xz/avidemux_core/ADM_coreVideoEncoder/ADM_hwAccelEncoder/ADM_coreNvenc/include/ADM_coreNvenc.h -> avidemux2-2.8.2.git20261026.tar.xz/avidemux_core/ADM_coreVideoEncoder/ADM_hwAccelEncoder/ADM_coreNvenc/include/ADM_coreNvenc.h Changed

@@ -16,12 +16,30 @@
  ***************************************************************************/
 #pragma once
 #include "ADM_default.h"
-#include "ADM_coreVideoEncoder6_export.h"
 
 #define ADM_NVENC_H264_IS_SUPPORTED 1
 #define ADM_NVENC_HEVC_IS_SUPPORTED (1<<1)
 #define ADM_NVENC_AV1_IS_SUPPORTED  (1<<2)
 
-ADM_COREVIDEOENCODER6_EXPORT bool ADM_getNvencCodecSupportFlags(uint32_t *flags);
+typedef struct {
+    // The caller should set codecId to 1, 2 or 4 for H264, HEVC or AV1 respectively.
+    // This bit will be cleared if the codec is not supported. In this case other
+    // fields must be ignored. If more than one bit is set in codecId by the caller,
+    // codecId will be set to zero and other fields must be considered invalid.
+    uint32_t codecId;
+    uint32_t rcMask;
+    uint32_t maxWidth;
+    uint32_t maxHeight;
+    int maxBframes;
+    uint32_t bframeRef; // bitmask of 0 = unsupported, 1 = each, 2 = middle, 4 = hierarchical
+    uint32_t lookahead; // if (lookahead & 1) level = (lookahead >> 1) & 0xF;
+    bool lossless;
+    bool temporalAq;
+    bool weightedPred;
+    bool highBitDepth;
+    bool multRefFrames;
+} admNvencCaps;
+
+bool ADM_getNvencCodecSupportFlags(admNvencCaps *caps);
 
 // EOF

avidemux2-2.8.2.git20261020.tar.xz/avidemux_core/ADM_coreVideoEncoder/ADM_hwAccelEncoder/ADM_coreNvenc/src/ADM_coreNvenc.cpp -> avidemux2-2.8.2.git20261026.tar.xz/avidemux_core/ADM_coreVideoEncoder/ADM_hwAccelEncoder/ADM_coreNvenc/src/ADM_coreNvenc.cpp Changed

@@ -26,6 +26,10 @@
 
 static uint32_t nvEncCodecSupportFlags = ADM_NVENC_NOT_PROBED;
 
+static admNvencCaps nvEncH264Caps;
+static admNvencCaps nvEncHEVCCaps;
+static admNvencCaps nvEncAV1Caps;
+
 // Code stolen from libavcodec/nvenc.{c,h}
 
 #define LAVC_NVENCAPI_CHECK_VERSION(major, minor) \
@@ -68,6 +72,248 @@
     ADM_error("The minimum required NVIDIA driver for NVENC is %s\n", minVersion);
 }
 
+static int checkCap(NV_ENCODE_API_FUNCTION_LIST *list, void *instance, GUID encGuid, NV_ENC_CAPS cap)
+{
+    NV_ENC_CAPS_PARAM caps;
+    int val = 0;
+    memset(&caps, 0, sizeof(caps));
+    caps.version = NV_ENC_CAPS_PARAM_VER;
+    caps.capsToQuery = cap;
+    NVENCSTATUS r = list->nvEncGetEncodeCaps(instance, encGuid, &caps, &val);
+
+    return (r == NV_ENC_SUCCESS) ? val : -1;
+}
+
+static void checkH264Caps(NV_ENCODE_API_FUNCTION_LIST *list, void *instance)
+{
+    memset(&nvEncH264Caps, 0, sizeof(admNvencCaps));
+
+    if (!(nvEncCodecSupportFlags & ADM_NVENC_H264_IS_SUPPORTED))
+        return;
+
+    nvEncH264Caps.codecId = ADM_NVENC_H264_IS_SUPPORTED;
+
+    int v;
+
+#define QUERY_CAP(x,y) v = checkCap(list, instance, NV_ENC_CODEC_H264_GUID, x); \
+    if (v >= 0) \
+    { \
+        nvEncH264Caps.y = v; \
+        ADM_info(#y " = %d\n", v); \
+    };
+
+    QUERY_CAP(NV_ENC_CAPS_SUPPORTED_RATECONTROL_MODES, rcMask)
+    QUERY_CAP(NV_ENC_CAPS_WIDTH_MAX, maxWidth)
+    QUERY_CAP(NV_ENC_CAPS_HEIGHT_MAX, maxHeight)
+    QUERY_CAP(NV_ENC_CAPS_NUM_MAX_BFRAMES, maxBframes)
+
+#undef QUERY_CAP
+#define QUERY_CAP(x,y) v = checkCap(list, instance, NV_ENC_CODEC_H264_GUID, x); \
+    if (v > 0) \
+    { \
+        nvEncH264Caps.y = true; \
+        ADM_info(#y " = true\n"); \
+    };
+
+    QUERY_CAP(NV_ENC_CAPS_SUPPORT_LOSSLESS_ENCODE, lossless)
+    QUERY_CAP(NV_ENC_CAPS_SUPPORT_TEMPORAL_AQ, temporalAq)
+    QUERY_CAP(NV_ENC_CAPS_SUPPORT_WEIGHTED_PREDICTION, weightedPred)
+    QUERY_CAP(NV_ENC_CAPS_SUPPORT_10BIT_ENCODE, highBitDepth)
+    QUERY_CAP(NV_ENC_CAPS_SUPPORT_MULTIPLE_REF_FRAMES, multRefFrames)
+
+#undef QUERY_CAP
+
+    v = checkCap(list, instance, NV_ENC_CODEC_H264_GUID, NV_ENC_CAPS_SUPPORT_BFRAME_REF_MODE);
+    if (v > 0)
+    {
+        nvEncH264Caps.bframeRef = v & 3;
+        ADM_info("bframeRef raw mask = %d\n", v);
+        v = checkCap(list, instance, NV_ENC_CODEC_H264_GUID, NV_ENC_CAPS_SUPPORT_HIERARCHICAL_BFRAMES);
+        if (v > 0)
+        {
+            nvEncH264Caps.bframeRef |= (1<<2);
+            ADM_info("Hierarchical B-frames are supported.\n");
+        }
+    }
+
+    v = checkCap(list, instance, NV_ENC_CODEC_H264_GUID, NV_ENC_CAPS_SUPPORT_LOOKAHEAD);
+    if (v > 0)
+    {
+        nvEncH264Caps.lookahead = 1;
+        ADM_info("lookahead = true\n");
+#if LAVC_NVENCAPI_CHECK_VERSION(12, 2)
+        v = checkCap(list, instance, NV_ENC_CODEC_H264_GUID, NV_ENC_CAPS_SUPPORT_LOOKAHEAD_LEVEL);
+        if (v > 0)
+        {
+            switch(v)
+            {
+                case NV_ENC_LOOKAHEAD_LEVEL_1:
+                case NV_ENC_LOOKAHEAD_LEVEL_2:
+                case NV_ENC_LOOKAHEAD_LEVEL_3:
+                case NV_ENC_LOOKAHEAD_LEVEL_AUTOSELECT:
+                    nvEncH264Caps.lookahead |= (v << 1);
+                    ADM_info("Raw max lookahead level = %d\n", v);
+                default: break; // invalid
+            }
+        }
+#endif
+    }
+}
+
+static void checkHEVCCaps(NV_ENCODE_API_FUNCTION_LIST *list, void *instance)
+{
+    memset(&nvEncHEVCCaps, 0, sizeof(admNvencCaps));
+
+    if (!(nvEncCodecSupportFlags & ADM_NVENC_HEVC_IS_SUPPORTED))
+        return;
+
+    nvEncHEVCCaps.codecId = ADM_NVENC_HEVC_IS_SUPPORTED;
+
+    int v;
+
+#define QUERY_CAP(x,y) v = checkCap(list, instance, NV_ENC_CODEC_HEVC_GUID, x); \
+    if (v >= 0) \
+    { \
+        nvEncHEVCCaps.y = v; \
+        ADM_info(#y " = %d\n", v); \
+    };
+
+    QUERY_CAP(NV_ENC_CAPS_SUPPORTED_RATECONTROL_MODES, rcMask)
+    QUERY_CAP(NV_ENC_CAPS_WIDTH_MAX, maxWidth)
+    QUERY_CAP(NV_ENC_CAPS_HEIGHT_MAX, maxHeight)
+    QUERY_CAP(NV_ENC_CAPS_NUM_MAX_BFRAMES, maxBframes)
+
+#undef QUERY_CAP
+#define QUERY_CAP(x,y) v = checkCap(list, instance, NV_ENC_CODEC_HEVC_GUID, x); \
+    if (v > 0) \
+    { \
+        nvEncHEVCCaps.y = true; \
+        ADM_info(#y " = true\n"); \
+    };
+
+    QUERY_CAP(NV_ENC_CAPS_SUPPORT_LOSSLESS_ENCODE, lossless)
+    QUERY_CAP(NV_ENC_CAPS_SUPPORT_TEMPORAL_AQ, temporalAq)
+    QUERY_CAP(NV_ENC_CAPS_SUPPORT_WEIGHTED_PREDICTION, weightedPred)
+    QUERY_CAP(NV_ENC_CAPS_SUPPORT_10BIT_ENCODE, highBitDepth)
+    QUERY_CAP(NV_ENC_CAPS_SUPPORT_MULTIPLE_REF_FRAMES, multRefFrames)
+
+#undef QUERY_CAP
+
+    v = checkCap(list, instance, NV_ENC_CODEC_HEVC_GUID, NV_ENC_CAPS_SUPPORT_BFRAME_REF_MODE);
+    if (v > 0)
+    {
+        nvEncHEVCCaps.bframeRef = v & 3;
+        ADM_info("bframeRef raw mask = %d\n", v);
+        v = checkCap(list, instance, NV_ENC_CODEC_HEVC_GUID, NV_ENC_CAPS_SUPPORT_HIERARCHICAL_BFRAMES);
+        if (v > 0)
+        {
+            nvEncHEVCCaps.bframeRef |= (1<<2);
+            ADM_info("Hierarchical B-frames are supported.\n");
+        }
+    }
+
+    v = checkCap(list, instance, NV_ENC_CODEC_HEVC_GUID, NV_ENC_CAPS_SUPPORT_LOOKAHEAD);
+    if (v > 0)
+    {
+        nvEncHEVCCaps.lookahead = 1;
+        ADM_info("lookahead = true\n");
+#if LAVC_NVENCAPI_CHECK_VERSION(12, 2)
+        v = checkCap(list, instance, NV_ENC_CODEC_HEVC_GUID, NV_ENC_CAPS_SUPPORT_LOOKAHEAD_LEVEL);
+        if (v > 0)
+        {
+            switch(v)
+            {
+                case NV_ENC_LOOKAHEAD_LEVEL_1:
+                case NV_ENC_LOOKAHEAD_LEVEL_2:
+                case NV_ENC_LOOKAHEAD_LEVEL_3:
+                case NV_ENC_LOOKAHEAD_LEVEL_AUTOSELECT:
+                    nvEncHEVCCaps.lookahead |= (v << 1);
+                    ADM_info("Raw max lookahead level = %d\n", v);
+                default: break; // invalid
+            }
+        }
+#endif
+    }
+}
+
+static void checkAV1Caps(NV_ENCODE_API_FUNCTION_LIST *list, void *instance)
+{
+    memset(&nvEncAV1Caps, 0, sizeof(admNvencCaps));
+
+#if LAVC_NVENCAPI_CHECK_VERSION(12, 0)
+    if (!(nvEncCodecSupportFlags & ADM_NVENC_AV1_IS_SUPPORTED))
+        return;
+
+    nvEncAV1Caps.codecId = ADM_NVENC_AV1_IS_SUPPORTED;
+
+    int v;
+
+#define QUERY_CAP(x,y) v = checkCap(list, instance, NV_ENC_CODEC_AV1_GUID, x); \
+    if (v >= 0) \
+    { \
+        nvEncAV1Caps.y = v; \
+        ADM_info(#y " = %d\n", v); \
+    };
+
+    QUERY_CAP(NV_ENC_CAPS_SUPPORTED_RATECONTROL_MODES, rcMask)
+    QUERY_CAP(NV_ENC_CAPS_WIDTH_MAX, maxWidth)
+    QUERY_CAP(NV_ENC_CAPS_HEIGHT_MAX, maxHeight)
+    QUERY_CAP(NV_ENC_CAPS_NUM_MAX_BFRAMES, maxBframes)
+
+#undef QUERY_CAP
+#define QUERY_CAP(x,y) v = checkCap(list, instance, NV_ENC_CODEC_AV1_GUID, x); \
+    if (v > 0) \
+    { \
+        nvEncAV1Caps.y = true; \
+        ADM_info(#y " = true\n"); \
+    };
+
+    QUERY_CAP(NV_ENC_CAPS_SUPPORT_LOSSLESS_ENCODE, lossless)
+    QUERY_CAP(NV_ENC_CAPS_SUPPORT_TEMPORAL_AQ, temporalAq)
+    QUERY_CAP(NV_ENC_CAPS_SUPPORT_WEIGHTED_PREDICTION, weightedPred)
+    QUERY_CAP(NV_ENC_CAPS_SUPPORT_10BIT_ENCODE, highBitDepth)
+    QUERY_CAP(NV_ENC_CAPS_SUPPORT_MULTIPLE_REF_FRAMES, multRefFrames)
+
+#undef QUERY_CAP
+
+    v = checkCap(list, instance, NV_ENC_CODEC_AV1_GUID, NV_ENC_CAPS_SUPPORT_BFRAME_REF_MODE);
+    if (v > 0)
+    {
+        nvEncAV1Caps.bframeRef = v & 3;
+        ADM_info("bframeRef raw mask = %d\n", v);
+        v = checkCap(list, instance, NV_ENC_CODEC_AV1_GUID, NV_ENC_CAPS_SUPPORT_HIERARCHICAL_BFRAMES);
+        if (v > 0)
+        {
+            nvEncAV1Caps.bframeRef |= (1<<2);
+            ADM_info("Hierarchical B-frames are supported.\n");
+        }
+    }
+
+    v = checkCap(list, instance, NV_ENC_CODEC_AV1_GUID, NV_ENC_CAPS_SUPPORT_LOOKAHEAD);
+    if (v > 0)
+    {
+        nvEncAV1Caps.lookahead = 1;
+        ADM_info("lookahead = true\n");
+#if LAVC_NVENCAPI_CHECK_VERSION(12, 2)
+        v = checkCap(list, instance, NV_ENC_CODEC_AV1_GUID, NV_ENC_CAPS_SUPPORT_LOOKAHEAD_LEVEL);
+        if (v > 0)
+        {
+            switch(v)
+            {
+                case NV_ENC_LOOKAHEAD_LEVEL_1:
+                case NV_ENC_LOOKAHEAD_LEVEL_2:
+                case NV_ENC_LOOKAHEAD_LEVEL_3:
+                case NV_ENC_LOOKAHEAD_LEVEL_AUTOSELECT:
+                    nvEncAV1Caps.lookahead |= (v << 1);
+                    ADM_info("Raw max lookahead level = %d\n", v);
+                default: break; // invalid
+            }
+        }
+#endif
+    }
+#endif
+}
+
 static bool checkNvEnc(void)
 {
     CudaFunctions *cudaDynl = NULL;
@@ -281,21 +527,30 @@
 
         for (int j = 0; j < nbGuids; j++)
         {
-             for (int k = 0; k < sizeof(allGuids) / sizeof(namedGuid); k++)
-             {
-                 if (!memcmp(&(guidsj), &(allGuidsk.guid), sizeof(*guids)))
-                 {
-                     ADM_info("%s is supported.\n", allGuidsk.name);
-                     if (!strcmp("H264", allGuidsk.name))
-                         nvEncCodecSupportFlags |= ADM_NVENC_H264_IS_SUPPORTED;
-                     else if (!strcmp("HEVC", allGuidsk.name))
-                         nvEncCodecSupportFlags |= ADM_NVENC_HEVC_IS_SUPPORTED;
-                     else if (!strcmp("AV1", allGuidsk.name))
-                         nvEncCodecSupportFlags |= ADM_NVENC_AV1_IS_SUPPORTED;
-                 }
-             }
+            for (int k = 0; k < sizeof(allGuids) / sizeof(namedGuid); k++)
+            {
+                if (!memcmp(&(guidsj), &(allGuidsk.guid), sizeof(*guids)))
+                {
+                    ADM_info("%s is supported.\n", allGuidsk.name);
+                    if (!strcmp("H264", allGuidsk.name))
+                        nvEncCodecSupportFlags |= ADM_NVENC_H264_IS_SUPPORTED;
+                    else if (!strcmp("HEVC", allGuidsk.name))
+                        nvEncCodecSupportFlags |= ADM_NVENC_HEVC_IS_SUPPORTED;
+                    else if (!strcmp("AV1", allGuidsk.name))
+                        nvEncCodecSupportFlags |= ADM_NVENC_AV1_IS_SUPPORTED;
+                }
+            }
         }
 
+        if (nvEncCodecSupportFlags & ADM_NVENC_H264_IS_SUPPORTED)
+            checkH264Caps(&nvencFunc, encoder);
+
+        if (nvEncCodecSupportFlags & ADM_NVENC_HEVC_IS_SUPPORTED)
+            checkHEVCCaps(&nvencFunc, encoder);
+
+        if (nvEncCodecSupportFlags & ADM_NVENC_AV1_IS_SUPPORTED)
+            checkAV1Caps(&nvencFunc, encoder);
+
         ADM_dealloc(guids);
         guids = NULL;
 
@@ -319,11 +574,33 @@
     return (nvEncCodecSupportFlags & (ADM_NVENC_H264_IS_SUPPORTED + ADM_NVENC_HEVC_IS_SUPPORTED + ADM_NVENC_AV1_IS_SUPPORTED));
 }
 
-bool ADM_getNvencCodecSupportFlags(uint32_t *flags)
+bool ADM_getNvencCodecSupportFlags(admNvencCaps *caps)
 {
     bool r = checkNvEnc();
-    if (flags)
-        *flags = nvEncCodecSupportFlags & 0xFFFF;
+    if (caps)
+    {
+        if (!r)
+        {
+            memset(caps, 0, sizeof(admNvencCaps));
+            return r;
+        }
+        switch(caps->codecId)
+        {
+            case ADM_NVENC_H264_IS_SUPPORTED:
+                memcpy(caps, &nvEncH264Caps, sizeof(admNvencCaps));
+                break;
+            case ADM_NVENC_HEVC_IS_SUPPORTED:
+                memcpy(caps, &nvEncHEVCCaps, sizeof(admNvencCaps));
+                break;
+            case ADM_NVENC_AV1_IS_SUPPORTED:
+                memcpy(caps, &nvEncAV1Caps, sizeof(admNvencCaps));
+                break;
+            default:
+                memset(caps, 0, sizeof(admNvencCaps));
+                break;
+        }
+    }
+
     return r;
 }

avidemux2-2.8.2.git20261020.tar.xz/avidemux_core/cmake/commonCmakeApplication.cmake -> avidemux2-2.8.2.git20261026.tar.xz/avidemux_core/cmake/commonCmakeApplication.cmake Changed

avidemux2-2.8.2.git20261020.tar.xz/avidemux_plugins/ADM_videoEncoder/ffNvEnc/ADM_ffNvEnc.cpp -> avidemux2-2.8.2.git20261026.tar.xz/avidemux_plugins/ADM_videoEncoder/ffNvEnc/ADM_ffNvEnc.cpp Changed

@@ -18,6 +18,7 @@
 
 #include "ADM_default.h"
 #include "ADM_ffNvEnc.h"
+#include "ADM_coreNvenc.h"
 #undef ADM_MINIMAL_UI_INTERFACE // we need the full UI
 #include "DIA_factory.h"
 //#define USE_NV12
@@ -137,7 +138,7 @@
     switch(NvEncSettings.rc_mode)
     {
         case NV_FF_RC_AUTO:
-            _context->bit_rate=NvEncSettings.bitrate*1000;
+            _context->bit_rate = 0;
             break;
         case NV_FF_RC_CONSTQP:
 #ifdef AV1_ENCODER
@@ -232,13 +233,6 @@
     targetPixFrmt = ADM_PIXFRMT_NV12;
 #endif
 
-    // Set encoder delay
-    int mult = (_context->max_b_frames > 0) ? 2 : 0;
-    if (_context->max_b_frames > 1)
-        mult += 1;
-    encoderDelay = frameIncrement * mult;
-    ADM_info("Encoder delay set to %d frames = %" PRIu64" us.\n", mult, encoderDelay);
-
     // Print nvenc options
     {
         AVDictionaryEntry *t = NULL;
@@ -358,11 +352,50 @@
 }
 
 /**
+    \fn ctor
+ */
+encCapsHelper::encCapsHelper(void)
+{
+    encoderCapabilities.codecId =
+#ifdef H265_ENCODER
+        ADM_NVENC_HEVC_IS_SUPPORTED;
+#elif defined(AV1_ENCODER)
+        ADM_NVENC_AV1_IS_SUPPORTED;
+#else
+        ADM_NVENC_H264_IS_SUPPORTED;
+#endif
+
+    if (false == ADM_getNvencCodecSupportFlags(&encoderCapabilities))
+        encoderCapabilities.codecId = 0;
+}
+/**
+    \fn getCaps
+    \brief Copy caps to provided target. Return true if codec is supported and caps are valid.
+ */
+bool encCapsHelper::getCaps(admNvencCaps *tgt)
+{
+    if (!encoderCapabilities.codecId)
+        return false;
+    if (tgt)
+        memcpy(tgt, &encoderCapabilities, sizeof(admNvencCaps));
+    return true;
+}
+
+/**
     \fn ffNvEncConfigure
     \brief Show configuration dialog
 */
 bool ffNvEncConfigure(void)
 {
+    encCapsHelper helper;
+    admNvencCaps caps;
+    caps.codecId = 0;
+    if (!helper.getCaps(&caps))
+    {
+        ADM_warning("Configuring encoder not supported by interface and hardware!\n");
+        caps.codecId = 0;
+    }
+
     diaMenuEntry meRcMode={
         {NV_FF_RC_AUTO,         QT_TRANSLATE_NOOP("ffnvenc","Controlled by Preset"),NULL},
         {NV_FF_RC_CONSTQP,      QT_TRANSLATE_NOOP("ffnvenc","Constant Quantizer"),NULL},
@@ -405,25 +438,49 @@
 #endif
     };
 
-    diaMenuEntry meNumRef={
-        {0,QT_TRANSLATE_NOOP("ffnvenc","Autoselect"),NULL},
-        {1,QT_TRANSLATE_NOOP("ffnvenc","1"),NULL},
-        {2,QT_TRANSLATE_NOOP("ffnvenc","2"),NULL},
-        {3,QT_TRANSLATE_NOOP("ffnvenc","3"),NULL},
-        {4,QT_TRANSLATE_NOOP("ffnvenc","4"),NULL},
-        {5,QT_TRANSLATE_NOOP("ffnvenc","5"),NULL},
-        {6,QT_TRANSLATE_NOOP("ffnvenc","6"),NULL},
-        {7,QT_TRANSLATE_NOOP("ffnvenc","7"),NULL}
-    };
+    diaMenuEntryDynamic **meBframeRefEntries = NULL;
+    uint32_t nbBframeRefMenuEntries = 1;
+    if (caps.codecId && (caps.bframeRef & 7))
+    {
+        if (caps.bframeRef & 1)
+            nbBframeRefMenuEntries++;
+        if (caps.bframeRef & 2)
+            nbBframeRefMenuEntries++;
+        if (caps.bframeRef & 4)
+            nbBframeRefMenuEntries++;
+    }
 
-    diaMenuEntry meBframeRef={
-        {NV_FF_BFRAME_REF_DISABLED,QT_TRANSLATE_NOOP("ffnvenc","Disabled"),NULL},
-        {NV_FF_BFRAME_REF_EACH,QT_TRANSLATE_NOOP("ffnvenc","Each"),NULL},
-        {NV_FF_BFRAME_REF_MIDDLE,QT_TRANSLATE_NOOP("ffnvenc","Middle"),NULL}
-#ifdef AV1_ENCODER
-        ,{NV_FF_BFRAME_REF_HIERARCHICAL,QT_TRANSLATE_NOOP("ffnvenc","Hierarchical"),NULL}
-#endif
-    };
+    meBframeRefEntries = new diaMenuEntryDynamic* nbBframeRefMenuEntries;
+    meBframeRefEntries0 = new diaMenuEntryDynamic(NV_FF_BFRAME_REF_DISABLED, QT_TRANSLATE_NOOP("ffnvenc","Disabled"), NULL);
+    if (caps.codecId && (caps.bframeRef & 1))
+        meBframeRefEntries1 = new diaMenuEntryDynamic(NV_FF_BFRAME_REF_EACH, QT_TRANSLATE_NOOP("ffnvenc","Each"), NULL);
+    if (caps.codecId && (caps.bframeRef & 2))
+        meBframeRefEntries2 = new diaMenuEntryDynamic(NV_FF_BFRAME_REF_MIDDLE, QT_TRANSLATE_NOOP("ffnvenc","Middle"), NULL);
+    if (caps.codecId && (caps.bframeRef & 4))
+        meBframeRefEntries3 = new diaMenuEntryDynamic(NV_FF_BFRAME_REF_HIERARCHICAL, QT_TRANSLATE_NOOP("ffnvenc","Hierarchical"), NULL);
+
+    diaMenuEntryDynamic **meMaxRefEntries = NULL;
+    uint32_t nbMaxRefMenuEntries = 1;
+#define REFS_MENU_MAX 8
+    if (caps.codecId && caps.multRefFrames)
+        nbMaxRefMenuEntries = REFS_MENU_MAX;
+
+    meMaxRefEntries = new diaMenuEntryDynamic* REFS_MENU_MAX;
+
+    char **meMaxRefMenuEntryTitles = new char* REFS_MENU_MAX;
+    meMaxRefMenuEntryTitles0 = ADM_strdup(QT_TRANSLATE_NOOP("ffnvenc","Autoselect"));
+    meMaxRefMenuEntryTitles1 = ADM_strdup(QT_TRANSLATE_NOOP("ffnvenc","1"));
+    meMaxRefMenuEntryTitles2 = ADM_strdup(QT_TRANSLATE_NOOP("ffnvenc","2"));
+    meMaxRefMenuEntryTitles3 = ADM_strdup(QT_TRANSLATE_NOOP("ffnvenc","3"));
+    meMaxRefMenuEntryTitles4 = ADM_strdup(QT_TRANSLATE_NOOP("ffnvenc","4"));
+    meMaxRefMenuEntryTitles5 = ADM_strdup(QT_TRANSLATE_NOOP("ffnvenc","5"));
+    meMaxRefMenuEntryTitles6 = ADM_strdup(QT_TRANSLATE_NOOP("ffnvenc","6"));
+    meMaxRefMenuEntryTitles7 = ADM_strdup(QT_TRANSLATE_NOOP("ffnvenc","7"));
+
+    for (int i = 0; i < nbMaxRefMenuEntries; i++)
+    {
+        meMaxRefEntriesi = new diaMenuEntryDynamic(i, meMaxRefMenuEntryTitlesi, NULL);
+    }
 
     ffnvenc_encoder *conf=&NvEncSettings;
 
@@ -433,25 +490,36 @@
     diaElemMenu qzPreset(PX(preset),QT_TRANSLATE_NOOP("ffnvenc","Preset:"),MZ(mePreset),mePreset);
     diaElemMenu tune(PX(tune),QT_TRANSLATE_NOOP("ffnvenc","Tune:"),MZ(meTune),meTune);
     diaElemMenu profile(PX(profile),QT_TRANSLATE_NOOP("ffnvenc","Profile:"),MZ(meProfile),meProfile);
-    diaElemMenu bFrameRef(PX(b_ref_mode),QT_TRANSLATE_NOOP("ffnvenc","Use B-Frames as References:"),MZ(meBframeRef),meBframeRef);
-    diaElemMenu maxRefs(PX(refs),QT_TRANSLATE_NOOP("ffnvenc","Maximum Reference Frames:"),MZ(meNumRef),meNumRef);
+
+    diaElemMenuDynamic *bFrameRef = new diaElemMenuDynamic(PX(b_ref_mode),
+                QT_TRANSLATE_NOOP("ffnvenc","Use B-Frames as References:"),
+                nbBframeRefMenuEntries, meBframeRefEntries);
+
+    diaElemMenuDynamic *maxRefs = new diaElemMenuDynamic(PX(refs),
+                QT_TRANSLATE_NOOP("ffnvenc","Maximum Reference Frames:"),
+                nbMaxRefMenuEntries, meMaxRefEntries);
 
 #ifdef AV1_ENCODER
-    diaElemUInteger qual(PX(quality),QT_TRANSLATE_NOOP("ffnvenc","Quality:"),0,63);
+# define MAX_QZ 63
 #else
-    diaElemUInteger qual(PX(quality),QT_TRANSLATE_NOOP("ffnvenc","Quality:"),0,51);
+# define MAX_QZ 51
 #endif
+    diaElemUInteger qual(PX(quality),QT_TRANSLATE_NOOP("ffnvenc","Quality:"), 0, MAX_QZ);
+#undef MAX_QZ
     diaElemUInteger bitrate(PX(bitrate),QT_TRANSLATE_NOOP("ffnvenc","Bitrate (kbps):"),1,500000);
     diaElemUInteger maxBitrate(PX(max_bitrate),QT_TRANSLATE_NOOP("ffnvenc","Max Bitrate (kbps):"),1,500000);
 
     diaElemUInteger gopSize(PX(gopsize),QT_TRANSLATE_NOOP("ffnvenc","GOP Size:"),0,1000);
-#ifdef AV1_ENCODER
-    diaElemUInteger maxBframes(PX(bframes),QT_TRANSLATE_NOOP("ffnvenc","Maximum Consecutive B-Frames:"),0,31);
-#else
-    diaElemUInteger maxBframes(PX(bframes),QT_TRANSLATE_NOOP("ffnvenc","Maximum Consecutive B-Frames:"),0,5);
-#endif
 
-    diaElemUInteger lookAhead(PX(lookahead),QT_TRANSLATE_NOOP("ffnvenc","Lookahead:"),0,64);
+    int mx = 31;
+    if (caps.codecId && caps.maxBframes > 0)
+    {
+        if (caps.maxBframes < mx)
+            mx = caps.maxBframes;
+    }
+    diaElemUInteger maxBframes(PX(bframes), QT_TRANSLATE_NOOP("ffnvenc","Maximum Consecutive B-Frames:"), 0, mx);
+
+    diaElemUInteger lookAhead(PX(lookahead),QT_TRANSLATE_NOOP("ffnvenc","Lookahead:"), 0, 31); // <= 31 - bframes
     diaElemUInteger aqStrength(PX(aq_strength),QT_TRANSLATE_NOOP("ffnvenc","AQ Strength:"),1,15);
 
     diaElemToggle spatAq(PX(spatial_aq),QT_TRANSLATE_NOOP("ffnvenc","Spatial AQ"));
@@ -480,7 +548,6 @@
     rateControl.swallow(&bitrate);
     rateControl.swallow(&maxBitrate);
 
-    rcmode.link(meRcMode,1,&bitrate);
     rcmode.link(meRcMode+1,1,&qual);
     rcmode.link(meRcMode+2,1,&bitrate);
     rcmode.link(meRcMode+3,1,&qual);
@@ -497,8 +564,8 @@
     frameControl.swallow(&gopSize);
     frameControl.swallow(&maxBframes);
 
-    refControl.swallow(&bFrameRef);
-    refControl.swallow(&maxRefs);
+    refControl.swallow(bFrameRef);
+    refControl.swallow(maxRefs);
 
 #define NB_ELEM(x) sizeof(x)/sizeof(diaElem *)
     /* First Tab : basic settings */
@@ -526,7 +593,7 @@
     diaElemTabs tabAdvanced(QT_TRANSLATE_NOOP("ffnvenc","Advanced Settings"),NB_ELEM(advanced),advanced);
 
     diaElemTabs *tabs={&tabBasic,&tabAdvanced};
-    if(diaFactoryRunTabs(
+    void *cookie = diaFactoryRunTabsPrepare(
 #ifdef H265_ENCODER
             QT_TRANSLATE_NOOP("ffnvenc","NVENC HEVC configuration"),
 #elif defined(AV1_ENCODER)
@@ -534,8 +601,52 @@
 #else
             QT_TRANSLATE_NOOP("ffnvenc","NVENC H.264 configuration"),
 #endif
-            2,tabs))
+            2, tabs);
+
+    // Disable unsupported stuff
+    maxBframes.enable(caps.codecId && caps.maxBframes > 0);
+    wPred.enable(caps.codecId && caps.lookahead);
+    tempAq.enable(caps.codecId && caps.temporalAq);
+    lookAhead.enable(caps.codecId && (caps.lookahead & 1));
+
+    bFrameRef->enable(caps.codecId && (caps.bframeRef & 3));
+    maxRefs->enable(caps.codecId && caps.multRefFrames);
+
+    uint8_t dialogAccepted = diaFactoryRunTabsFinish(cookie);
+
+    // cleanup
+
+    // free maxRefs menu
+    for (int i = 0; i < nbMaxRefMenuEntries; i++)
+    {
+        delete meMaxRefEntriesi;
+    }
+    delete  meMaxRefEntries;
+    meMaxRefEntries = NULL;
+    delete maxRefs;
+    maxRefs = NULL;
+
+    for (int i = 0; i < REFS_MENU_MAX; i++)
+    {
+        ADM_dezalloc(meMaxRefMenuEntryTitlesi);
+        meMaxRefMenuEntryTitlesi = NULL;
+    }
+    delete  meMaxRefMenuEntryTitles;
+    meMaxRefMenuEntryTitles = NULL;
+
+    // free bFrameRef menu
+    for (int i = 0; i < nbBframeRefMenuEntries; i++)
+    {
+        delete meBframeRefEntriesi;
+    }
+    delete  meBframeRefEntries;
+    meBframeRefEntries = NULL;
+    delete bFrameRef;
+    bFrameRef = NULL;
+
+    if (dialogAccepted)
         return true;
+
     return false;
 }
 // EOF

avidemux2-2.8.2.git20261020.tar.xz/avidemux_plugins/ADM_videoEncoder/ffNvEnc/ADM_ffNvEnc.h -> avidemux2-2.8.2.git20261026.tar.xz/avidemux_plugins/ADM_videoEncoder/ffNvEnc/ADM_ffNvEnc.h Changed

@@ -17,6 +17,7 @@
  ***************************************************************************/
 #pragma once
 #include "ADM_coreVideoEncoderFFmpeg.h"
+#include "ADM_coreNvenc.h"
 #include "ffnvenc.h"
 
 enum FF_NVencTune
@@ -78,15 +79,15 @@
   NV_FF_PRESET_P4, /* preset */ \
   NV_FF_PROFILE_MAIN, /* profile */ \
   NV_FF_TUNE_HQ, /* tune */ \
-  NV_FF_RC_AUTO, /* rc_mode */ \
+  NV_FF_RC_CONSTQP, /* rc_mode */ \
   20,    /* quality */ \
   5000, /* bitrate */ \
   10000, /* max_bitrate */ \
-  100,   /* gopsize */ \
+  250,   /* gopsize */ \
   0, /* refs */ \
   2, /* bframes */ \
   2, /* b_ref_mode */ \
-  0, /* lookahead */ \
+  8, /* lookahead */ \
   8, /* aq_strength */ \
   0, /* spatial_aq */ \
   0, /* temporal_aq */ \
@@ -98,15 +99,15 @@
   NV_FF_PRESET_P4, /* preset */ \
   0, /* AV1 does not have profile options */ \
   NV_FF_TUNE_HQ, /* tune */ \
-  NV_FF_RC_AUTO, /* rc_mode */ \
+  NV_FF_RC_CONSTQP, /* rc_mode */ \
   25,    /* quality */ \
   5000, /* bitrate */ \
   10000, /* max_bitrate */ \
-  100,   /* gopsize */ \
+  250,   /* gopsize */ \
   0, /* refs */ \
   2, /* bframes */ \
   2, /* b_ref_mode */ \
-  0, /* lookahead */ \
+  8, /* lookahead */ \
   8, /* aq_strength */ \
   0, /* spatial_aq */ \
   0, /* temporal_aq */ \
@@ -118,15 +119,15 @@
   NV_FF_PRESET_P4, /* preset */ \
   NV_FF_PROFILE_HIGH, /* profile */ \
   NV_FF_TUNE_HQ,       /* tune */ \
-  NV_FF_RC_AUTO, /* rc_mode */ \
+  NV_FF_RC_CONSTQP, /* rc_mode */ \
   20,    /* quality */ \
   10000, /* bitrate */ \
   20000, /* max_bitrate */ \
-  100,   /* gopsize */ \
+  250,   /* gopsize */ \
   0, /* refs */ \
   2, /* bframes */ \
   1, /* b_ref_mode */ \
-  0, /* lookahead */ \
+  8, /* lookahead */ \
   8, /* aq_strength */ \
   0, /* spatial_aq */ \
   0, /* temporal_aq */ \
@@ -152,3 +153,17 @@
 virtual const  char        *getFourcc(void);
 };
 
+/**
+    \class encCapsHelper
+    \brief Get hardware capabilities
+*/
+class encCapsHelper
+{
+protected:
+    admNvencCaps    encoderCapabilities;
+public:
+                    encCapsHelper();
+                    ~encCapsHelper() { };
+    bool            getCaps(admNvencCaps *target);
+};
+

avidemux2-2.8.2.git20261020.tar.xz/avidemux_plugins/ADM_videoEncoder/ffNvEnc/ffNvEncPlugin.cpp -> avidemux2-2.8.2.git20261026.tar.xz/avidemux_plugins/ADM_videoEncoder/ffNvEnc/ffNvEncPlugin.cpp Changed

Changes of Revision 49