Changeset 1572b92


Ignore:
Timestamp:
06/27/15 22:10:00 (10 months ago)
Author:
Rodeo <tdskywalker@…>
Branches:
master
Children:
bd62cb0
Parents:
28766d6
Message:

QSV: add new capability guards for some extended video parameter buffers.

git-svn-id: svn://svn.handbrake.fr/HandBrake/trunk@7326 b64f7644-9d1e-0410-96f1-a4d463321fa5

Location:
libhb
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • libhb/enc_qsv.c

    r28766d6 r1572b92  
    912912    option1->Header.BufferId = MFX_EXTBUFF_CODING_OPTION;
    913913    option1->Header.BufferSz = sizeof(mfxExtCodingOption);
    914     videoParam.ExtParam[videoParam.NumExtParam++] = (mfxExtBuffer*)option1;
     914    if (pv->qsv_info->capabilities & HB_QSV_CAP_OPTION1)
     915    {
     916        videoParam.ExtParam[videoParam.NumExtParam++] = (mfxExtBuffer*)option1;
     917    }
    915918    // introduced in API 1.6
    916919    memset(option2, 0, sizeof(mfxExtCodingOption2));
    917920    option2->Header.BufferId = MFX_EXTBUFF_CODING_OPTION2;
    918921    option2->Header.BufferSz = sizeof(mfxExtCodingOption2);
    919     if (pv->qsv_info->capabilities & HB_QSV_CAP_MSDK_API_1_6)
    920     {
    921         // attach to get the final output mfxExtCodingOption2 settings
     922    if (pv->qsv_info->capabilities & HB_QSV_CAP_OPTION2)
     923    {
    922924        videoParam.ExtParam[videoParam.NumExtParam++] = (mfxExtBuffer*)option2;
    923925    }
     
    11001102            return -1;
    11011103    }
    1102     if (option1->CAVLC != MFX_CODINGOPTION_OFF)
    1103     {
    1104         hb_log("encqsvInit: CAVLC %s",
    1105                hb_qsv_codingoption_get_name(option1->CAVLC));
     1104    if (pv->qsv_info->capabilities & HB_QSV_CAP_OPTION1)
     1105    {
     1106        if (videoParam.mfx.CodecId == MFX_CODEC_AVC)
     1107        {
     1108            if (option1->CAVLC != MFX_CODINGOPTION_OFF)
     1109            {
     1110                hb_log("encqsvInit: CAVLC %s",
     1111                       hb_qsv_codingoption_get_name(option1->CAVLC));
     1112            }
     1113        }
    11061114    }
    11071115    if (pv->qsv_info->capabilities & HB_QSV_CAP_OPTION2_EXTBRC)
  • libhb/qsv_common.c

    r28766d6 r1572b92  
    168168}
    169169
     170static void init_ext_video_signal_info(mfxExtVideoSignalInfo *extVideoSignalInfo)
     171{
     172    if (extVideoSignalInfo == NULL)
     173    {
     174        return;
     175    }
     176
     177    memset(extVideoSignalInfo, 0, sizeof(mfxExtVideoSignalInfo));
     178    extVideoSignalInfo->Header.BufferId          = MFX_EXTBUFF_VIDEO_SIGNAL_INFO;
     179    extVideoSignalInfo->Header.BufferSz          = sizeof(mfxExtVideoSignalInfo);
     180    extVideoSignalInfo->VideoFormat              = 5; // undefined
     181    extVideoSignalInfo->VideoFullRange           = 0; // TV range
     182    extVideoSignalInfo->ColourDescriptionPresent = 0; // don't write to bitstream
     183    extVideoSignalInfo->ColourPrimaries          = 2; // undefined
     184    extVideoSignalInfo->TransferCharacteristics  = 2; // undefined
     185    extVideoSignalInfo->MatrixCoefficients       = 2; // undefined
     186}
     187
     188static void init_ext_coding_option(mfxExtCodingOption *extCodingOption)
     189{
     190    if (extCodingOption == NULL)
     191    {
     192        return;
     193    }
     194
     195    memset(extCodingOption, 0, sizeof(mfxExtCodingOption));
     196    extCodingOption->Header.BufferId = MFX_EXTBUFF_CODING_OPTION;
     197    extCodingOption->Header.BufferSz = sizeof(mfxExtCodingOption);
     198    extCodingOption->AUDelimiter     = MFX_CODINGOPTION_OFF;
     199    extCodingOption->PicTimingSEI    = MFX_CODINGOPTION_OFF;
     200    extCodingOption->CAVLC           = MFX_CODINGOPTION_OFF;
     201}
     202
    170203static void init_ext_coding_option2(mfxExtCodingOption2 *extCodingOption2)
    171204{
     
    210243    mfxExtBuffer *videoExtParam[1];
    211244    mfxVideoParam videoParam, inputParam;
    212     mfxExtCodingOption2 extCodingOption2;
     245    mfxExtCodingOption    extCodingOption;
     246    mfxExtCodingOption2   extCodingOption2;
     247    mfxExtVideoSignalInfo extVideoSignalInfo;
    213248
    214249    /* Reset capabilities before querying */
     
    362397
    363398        /*
    364          * Check mfxExtCodingOption2 fields.
     399         * Determine whether mfxExtVideoSignalInfo is supported.
     400         */
     401        if (HB_CHECK_MFX_VERSION(version, 1, 3))
     402        {
     403            init_video_param(&videoParam);
     404            videoParam.mfx.CodecId = info->codec_id;
     405
     406            init_ext_video_signal_info(&extVideoSignalInfo);
     407            videoParam.ExtParam    = videoExtParam;
     408            videoParam.ExtParam[0] = (mfxExtBuffer*)&extVideoSignalInfo;
     409            videoParam.NumExtParam = 1;
     410
     411            status = MFXVideoENCODE_Query(session, NULL, &videoParam);
     412            if (status >= MFX_ERR_NONE)
     413            {
     414                /* Encoder can be configured via mfxExtVideoSignalInfo */
     415                info->capabilities |= HB_QSV_CAP_VUI_VSINFO;
     416            }
     417            else if (info->codec_id == MFX_CODEC_AVC)
     418            {
     419                /*
     420                 * This should not fail for AVC encoders, so we want to know
     421                 * about it - however, it may fail for other encoders (ignore)
     422                 */
     423                fprintf(stderr,
     424                        "hb_qsv_info_init: mfxExtVideoSignalInfo check"
     425                        " failed (0x%"PRIX32", 0x%"PRIX32", %d)\n",
     426                        info->codec_id, info->implementation, status);
     427            }
     428        }
     429
     430        /*
     431         * Determine whether mfxExtCodingOption is supported.
     432         */
     433        if (HB_CHECK_MFX_VERSION(version, 1, 0))
     434        {
     435            init_video_param(&videoParam);
     436            videoParam.mfx.CodecId = info->codec_id;
     437
     438            init_ext_coding_option(&extCodingOption);
     439            videoParam.ExtParam    = videoExtParam;
     440            videoParam.ExtParam[0] = (mfxExtBuffer*)&extCodingOption;
     441            videoParam.NumExtParam = 1;
     442
     443            status = MFXVideoENCODE_Query(session, NULL, &videoParam);
     444            if (status >= MFX_ERR_NONE)
     445            {
     446                /* Encoder can be configured via mfxExtCodingOption */
     447                info->capabilities |= HB_QSV_CAP_OPTION1;
     448            }
     449            else if (info->codec_id == MFX_CODEC_AVC)
     450            {
     451                /*
     452                 * This should not fail for AVC encoders, so we want to know
     453                 * about it - however, it may fail for other encoders (ignore)
     454                 */
     455                fprintf(stderr,
     456                        "hb_qsv_info_init: mfxExtCodingOption check"
     457                        " failed (0x%"PRIX32", 0x%"PRIX32", %d)\n",
     458                        info->codec_id, info->implementation, status);
     459            }
     460        }
     461
     462        /*
     463         * Determine whether mfxExtCodingOption2 and its fields are supported.
    365464         *
    366465         * Mode 2 suffers from false negatives with some drivers, whereas mode 1
     
    394493                fprintf(stderr, "-------------------\n");
    395494#endif
     495
     496                /* Encoder can be configured via mfxExtCodingOption2 */
     497                info->capabilities |= HB_QSV_CAP_OPTION2;
    396498
    397499                /*
     
    599701        strcat(buffer, " icq");
    600702    }
    601     if (caps & HB_QSV_CAP_OPTION2_MBBRC)
    602     {
    603             strcat(buffer, " mbbrc");
    604     }
    605     if (caps & HB_QSV_CAP_OPTION2_EXTBRC)
    606     {
    607         strcat(buffer, " extbrc");
    608     }
    609     if (caps & HB_QSV_CAP_OPTION2_TRELLIS)
    610     {
    611         strcat(buffer, " trellis");
    612     }
    613     if (caps & HB_QSV_CAP_OPTION2_IB_ADAPT)
    614     {
    615         strcat(buffer, " ib_adapt");
    616     }
    617     if (caps & HB_QSV_CAP_OPTION2_NMPSLICE)
    618     {
    619         strcat(buffer, " nmpslice");
     703    if (caps & HB_QSV_CAP_VUI_VSINFO)
     704    {
     705        strcat(buffer, " vsinfo");
     706    }
     707    if (caps & HB_QSV_CAP_OPTION1)
     708    {
     709        strcat(buffer, " opt1");
     710    }
     711    if (caps & HB_QSV_CAP_OPTION2)
     712    {
     713        {
     714            strcat(buffer, " opt2");
     715        }
     716        if (caps & HB_QSV_CAP_OPTION2_MBBRC)
     717        {
     718            strcat(buffer, "+mbbrc");
     719        }
     720        if (caps & HB_QSV_CAP_OPTION2_EXTBRC)
     721        {
     722            strcat(buffer, "+extbrc");
     723        }
     724        if (caps & HB_QSV_CAP_OPTION2_TRELLIS)
     725        {
     726            strcat(buffer, "+trellis");
     727        }
     728        if (caps & HB_QSV_CAP_OPTION2_IB_ADAPT)
     729        {
     730            strcat(buffer, "+ib_adapt");
     731        }
     732        if (caps & HB_QSV_CAP_OPTION2_NMPSLICE)
     733        {
     734            strcat(buffer, "+nmpslice");
     735        }
    620736    }
    621737
     
    10231139    else if (!strcasecmp(key, "cavlc") || !strcasecmp(key, "cabac"))
    10241140    {
    1025         switch (info->codec_id)
    1026         {
    1027             case MFX_CODEC_AVC:
    1028                 ivalue = hb_qsv_atobool(value, &error);
    1029                 break;
    1030             default:
    1031                 return HB_QSV_PARAM_UNSUPPORTED;
     1141        if (info->capabilities & HB_QSV_CAP_OPTION1)
     1142        {
     1143            switch (info->codec_id)
     1144            {
     1145                case MFX_CODEC_AVC:
     1146                    ivalue = hb_qsv_atobool(value, &error);
     1147                    break;
     1148                default:
     1149                    return HB_QSV_PARAM_UNSUPPORTED;
     1150            }
     1151        }
     1152        else
     1153        {
     1154            return HB_QSV_PARAM_UNSUPPORTED;
    10321155        }
    10331156        if (!error)
     
    10421165    else if (!strcasecmp(key, "videoformat"))
    10431166    {
    1044         switch (info->codec_id)
    1045         {
    1046             case MFX_CODEC_AVC:
    1047                 ivalue = hb_qsv_atoindex(hb_h264_vidformat_names, value, &error);
    1048                 break;
    1049             default:
    1050                 return HB_QSV_PARAM_UNSUPPORTED;
     1167        if (info->capabilities & HB_QSV_CAP_VUI_VSINFO)
     1168        {
     1169            switch (info->codec_id)
     1170            {
     1171                case MFX_CODEC_AVC:
     1172                    ivalue = hb_qsv_atoindex(hb_h264_vidformat_names, value, &error);
     1173                    break;
     1174                default:
     1175                    return HB_QSV_PARAM_UNSUPPORTED;
     1176            }
     1177        }
     1178        else
     1179        {
     1180            return HB_QSV_PARAM_UNSUPPORTED;
    10511181        }
    10521182        if (!error)
     
    10571187    else if (!strcasecmp(key, "fullrange"))
    10581188    {
    1059         switch (info->codec_id)
    1060         {
    1061             case MFX_CODEC_AVC:
    1062                 ivalue = hb_qsv_atoindex(hb_h264_fullrange_names, value, &error);
    1063                 break;
    1064             default:
    1065                 return HB_QSV_PARAM_UNSUPPORTED;
     1189        if (info->capabilities & HB_QSV_CAP_VUI_VSINFO)
     1190        {
     1191            switch (info->codec_id)
     1192            {
     1193                case MFX_CODEC_AVC:
     1194                    ivalue = hb_qsv_atoindex(hb_h264_fullrange_names, value, &error);
     1195                    break;
     1196                default:
     1197                    return HB_QSV_PARAM_UNSUPPORTED;
     1198            }
     1199        }
     1200        else
     1201        {
     1202            return HB_QSV_PARAM_UNSUPPORTED;
    10661203        }
    10671204        if (!error)
     
    10721209    else if (!strcasecmp(key, "colorprim"))
    10731210    {
    1074         switch (info->codec_id)
    1075         {
    1076             case MFX_CODEC_AVC:
    1077                 ivalue = hb_qsv_atoindex(hb_h264_colorprim_names, value, &error);
    1078                 break;
    1079             default:
    1080                 return HB_QSV_PARAM_UNSUPPORTED;
     1211        if (info->capabilities & HB_QSV_CAP_VUI_VSINFO)
     1212        {
     1213            switch (info->codec_id)
     1214            {
     1215                case MFX_CODEC_AVC:
     1216                    ivalue = hb_qsv_atoindex(hb_h264_colorprim_names, value, &error);
     1217                    break;
     1218                default:
     1219                    return HB_QSV_PARAM_UNSUPPORTED;
     1220            }
     1221        }
     1222        else
     1223        {
     1224            return HB_QSV_PARAM_UNSUPPORTED;
    10811225        }
    10821226        if (!error)
     
    10881232    else if (!strcasecmp(key, "transfer"))
    10891233    {
    1090         switch (info->codec_id)
    1091         {
    1092             case MFX_CODEC_AVC:
    1093                 ivalue = hb_qsv_atoindex(hb_h264_transfer_names, value, &error);
    1094                 break;
    1095             default:
    1096                 return HB_QSV_PARAM_UNSUPPORTED;
     1234        if (info->capabilities & HB_QSV_CAP_VUI_VSINFO)
     1235        {
     1236            switch (info->codec_id)
     1237            {
     1238                case MFX_CODEC_AVC:
     1239                    ivalue = hb_qsv_atoindex(hb_h264_transfer_names, value, &error);
     1240                    break;
     1241                default:
     1242                    return HB_QSV_PARAM_UNSUPPORTED;
     1243            }
     1244        }
     1245        else
     1246        {
     1247            return HB_QSV_PARAM_UNSUPPORTED;
    10971248        }
    10981249        if (!error)
     
    11041255    else if (!strcasecmp(key, "colormatrix"))
    11051256    {
    1106         switch (info->codec_id)
    1107         {
    1108             case MFX_CODEC_AVC:
    1109                 ivalue = hb_qsv_atoindex(hb_h264_colmatrix_names, value, &error);
    1110                 break;
    1111             default:
    1112                 return HB_QSV_PARAM_UNSUPPORTED;
     1257        if (info->capabilities & HB_QSV_CAP_VUI_VSINFO)
     1258        {
     1259            switch (info->codec_id)
     1260            {
     1261                case MFX_CODEC_AVC:
     1262                    ivalue = hb_qsv_atoindex(hb_h264_colmatrix_names, value, &error);
     1263                    break;
     1264                default:
     1265                    return HB_QSV_PARAM_UNSUPPORTED;
     1266            }
     1267        }
     1268        else
     1269        {
     1270            return HB_QSV_PARAM_UNSUPPORTED;
    11131271        }
    11141272        if (!error)
     
    16231781        param->videoParam->NumExtParam                                = 0;
    16241782        param->videoParam->ExtParam                                   = param->ExtParamArray;
    1625         param->videoParam->ExtParam[param->videoParam->NumExtParam++] = (mfxExtBuffer*)&param->codingOption;
    1626         param->videoParam->ExtParam[param->videoParam->NumExtParam++] = (mfxExtBuffer*)&param->videoSignalInfo;
    1627         if (info->capabilities & HB_QSV_CAP_MSDK_API_1_6)
     1783        if (info->capabilities & HB_QSV_CAP_VUI_VSINFO)
     1784        {
     1785            param->videoParam->ExtParam[param->videoParam->NumExtParam++] = (mfxExtBuffer*)&param->videoSignalInfo;
     1786        }
     1787        if (info->capabilities & HB_QSV_CAP_OPTION1)
     1788        {
     1789            param->videoParam->ExtParam[param->videoParam->NumExtParam++] = (mfxExtBuffer*)&param->codingOption;
     1790        }
     1791        if (info->capabilities & HB_QSV_CAP_OPTION2)
    16281792        {
    16291793            param->videoParam->ExtParam[param->videoParam->NumExtParam++] = (mfxExtBuffer*)&param->codingOption2;
  • libhb/qsv_common.h

    r28766d6 r1572b92  
    4343    // H.264, H.265: B-frames can be used as references
    4444#define HB_QSV_CAP_B_REF_PYRAMID     (1LL <<  1)
     45    // mfxExtVideoSignalInfo
     46#define HB_QSV_CAP_VUI_VSINFO        (1LL <<  3)
    4547    // optional rate control methods
    4648#define HB_QSV_CAP_RATECONTROL_LA    (1LL << 10)
    4749#define HB_QSV_CAP_RATECONTROL_LAi   (1LL << 11)
    4850#define HB_QSV_CAP_RATECONTROL_ICQ   (1LL << 12)
    49     // mfxExtCodingOption2 fields
    50 #define HB_QSV_CAP_OPTION2_MBBRC     (1LL << 20)
    51 #define HB_QSV_CAP_OPTION2_EXTBRC    (1LL << 21)
    52 #define HB_QSV_CAP_OPTION2_TRELLIS   (1LL << 22)
    53 #define HB_QSV_CAP_OPTION2_BREFTYPE  (1LL << 23)
    54 #define HB_QSV_CAP_OPTION2_IB_ADAPT  (1LL << 24)
    55 #define HB_QSV_CAP_OPTION2_LA_DOWNS  (1LL << 25)
    56 #define HB_QSV_CAP_OPTION2_NMPSLICE  (1LL << 26)
     51    // mfxExtCodingOption
     52#define HB_QSV_CAP_OPTION1           (1LL << 20)
     53    // mfxExtCodingOption2
     54#define HB_QSV_CAP_OPTION2           (1LL << 30)
     55#define HB_QSV_CAP_OPTION2_MBBRC     (1LL << 31)
     56#define HB_QSV_CAP_OPTION2_EXTBRC    (1LL << 32)
     57#define HB_QSV_CAP_OPTION2_TRELLIS   (1LL << 33)
     58#define HB_QSV_CAP_OPTION2_BREFTYPE  (1LL << 34)
     59#define HB_QSV_CAP_OPTION2_IB_ADAPT  (1LL << 35)
     60#define HB_QSV_CAP_OPTION2_LA_DOWNS  (1LL << 36)
     61#define HB_QSV_CAP_OPTION2_NMPSLICE  (1LL << 37)
    5762
    5863    // TODO: add maximum encode resolution, etc.
Note: See TracChangeset for help on using the changeset viewer.