History

qsv: add requirement for the mininal version of libmfx

libmfx 1.28 was released 3 years ago, it is easy to get a greater version than 1.28. We may remove lots of compile-time checks if adding the requirement for the minimal version in the configure script.

Haihao Xiang committed 4 years ago

Commit 478e1a91 parent f8a07c49 files · +250 −482Browse files

Unified · Split

9 files
  1. configure +5 −2
  2. libavcodec/qsv.c +0 −24
  3. libavcodec/qsvenc.c +168 −308
  4. libavcodec/qsvenc.h +9 −42
  5. libavcodec/qsvenc_h264.c +0 −6
  6. libavcodec/qsvenc_hevc.c +0 −10
  7. libavfilter/vf_scale_qsv.c +1 −12
  8. libavfilter/vf_vpp_qsv.c +67 −76
  9. libavutil/hwcontext_qsv.c +0 −2
configure+5−2
@@ -6566,8 +6566,11 @@ enabled liblensfun && require_pkg_config liblensfun lensfun lensfun.h lf_ · 6565 unmodified lines
6566# Media SDK or Intel Media Server Studio, these don't come with6566# Media SDK or Intel Media Server Studio, these don't come with
6567# pkg-config support. Instead, users should make sure that the build6567# pkg-config support. Instead, users should make sure that the build
6568# can find the libraries and headers through other means.6568# can find the libraries and headers through other means.
6569enabled libmfx && { check_pkg_config libmfx libmfx "mfx/mfxvideo.h" MFXInit ||6569enabled libmfx && { check_pkg_config libmfx "mfx >= 1.28" "mfx/mfxvideo.h" MFXInit ||
6570 { require libmfx "mfx/mfxvideo.h" MFXInit "-llibmfx $advapi32_extralibs" && warn "using libmfx without pkg-config"; } }6570 { require libmfx "mfx/mfxvideo.h mfx/mfxdefs.h" MFXInit "-llibmfx $advapi32_extralibs" &&
6571 { test_cpp_condition mfx/mfxdefs.h "MFX_VERSION >= 1028" || die "ERROR: libmfx version must be >= 1.28"; } &&
6572 warn "using libmfx without pkg-config"; } }
6573
6571if enabled libmfx; then6574if enabled libmfx; then
6572 check_cc MFX_CODEC_VP9 "mfx/mfxvp9.h mfx/mfxstructures.h" "MFX_CODEC_VP9"6575 check_cc MFX_CODEC_VP9 "mfx/mfxvp9.h mfx/mfxstructures.h" "MFX_CODEC_VP9"
6573fi6576fi
libavcodec/qsv.c+0−24
@@ -38,34 +38,26 @@ · 37 unmodified lines
38 38
39#define MFX_IMPL_VIA_MASK(impl) (0x0f00 & (impl))39#define MFX_IMPL_VIA_MASK(impl) (0x0f00 & (impl))
40 40
41#if QSV_VERSION_ATLEAST(1, 12)
42#include "mfx/mfxvp8.h"41#include "mfx/mfxvp8.h"
43#endif
44 42
45int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id)43int ff_qsv_codec_id_to_mfx(enum AVCodecID codec_id)
46{44{
47 switch (codec_id) {45 switch (codec_id) {
48 case AV_CODEC_ID_H264:46 case AV_CODEC_ID_H264:
49 return MFX_CODEC_AVC;47 return MFX_CODEC_AVC;
50#if QSV_VERSION_ATLEAST(1, 8)
51 case AV_CODEC_ID_HEVC:48 case AV_CODEC_ID_HEVC:
52 return MFX_CODEC_HEVC;49 return MFX_CODEC_HEVC;
53#endif
54 case AV_CODEC_ID_MPEG1VIDEO:50 case AV_CODEC_ID_MPEG1VIDEO:
55 case AV_CODEC_ID_MPEG2VIDEO:51 case AV_CODEC_ID_MPEG2VIDEO:
56 return MFX_CODEC_MPEG2;52 return MFX_CODEC_MPEG2;
57 case AV_CODEC_ID_VC1:53 case AV_CODEC_ID_VC1:
58 return MFX_CODEC_VC1;54 return MFX_CODEC_VC1;
59#if QSV_VERSION_ATLEAST(1, 12)
60 case AV_CODEC_ID_VP8:55 case AV_CODEC_ID_VP8:
61 return MFX_CODEC_VP8;56 return MFX_CODEC_VP8;
62#endif
63 case AV_CODEC_ID_MJPEG:57 case AV_CODEC_ID_MJPEG:
64 return MFX_CODEC_JPEG;58 return MFX_CODEC_JPEG;
65#if QSV_VERSION_ATLEAST(1, 19)
66 case AV_CODEC_ID_VP9:59 case AV_CODEC_ID_VP9:
67 return MFX_CODEC_VP9;60 return MFX_CODEC_VP9;
68#endif
69#if QSV_VERSION_ATLEAST(1, 34)61#if QSV_VERSION_ATLEAST(1, 34)
70 case AV_CODEC_ID_AV1:62 case AV_CODEC_ID_AV1:
71 return MFX_CODEC_AV1;63 return MFX_CODEC_AV1;
@@ -189,17 +181,11 @@ enum AVPixelFormat ff_qsv_map_fourcc(uint32_t fourcc) · 117 unmodified lines
189 case MFX_FOURCC_NV12: return AV_PIX_FMT_NV12;181 case MFX_FOURCC_NV12: return AV_PIX_FMT_NV12;
190 case MFX_FOURCC_P010: return AV_PIX_FMT_P010;182 case MFX_FOURCC_P010: return AV_PIX_FMT_P010;
191 case MFX_FOURCC_P8: return AV_PIX_FMT_PAL8;183 case MFX_FOURCC_P8: return AV_PIX_FMT_PAL8;
192#if QSV_VERSION_ATLEAST(1, 9)
193 case MFX_FOURCC_A2RGB10: return AV_PIX_FMT_X2RGB10;184 case MFX_FOURCC_A2RGB10: return AV_PIX_FMT_X2RGB10;
194#endif
195#if QSV_VERSION_ATLEAST(1, 17)
196 case MFX_FOURCC_RGB4: return AV_PIX_FMT_BGRA;185 case MFX_FOURCC_RGB4: return AV_PIX_FMT_BGRA;
197#endif
198#if CONFIG_VAAPI186#if CONFIG_VAAPI
199 case MFX_FOURCC_YUY2: return AV_PIX_FMT_YUYV422;187 case MFX_FOURCC_YUY2: return AV_PIX_FMT_YUYV422;
200#if QSV_VERSION_ATLEAST(1, 27)
201 case MFX_FOURCC_Y210: return AV_PIX_FMT_Y210;188 case MFX_FOURCC_Y210: return AV_PIX_FMT_Y210;
202#endif
203#endif189#endif
204 }190 }
205 return AV_PIX_FMT_NONE;191 return AV_PIX_FMT_NONE;
@@ -217,27 +203,21 @@ int ff_qsv_map_pixfmt(enum AVPixelFormat format, uint32_t *fourcc) · 11 unmodified lines
217 case AV_PIX_FMT_P010:203 case AV_PIX_FMT_P010:
218 *fourcc = MFX_FOURCC_P010;204 *fourcc = MFX_FOURCC_P010;
219 return AV_PIX_FMT_P010;205 return AV_PIX_FMT_P010;
220#if QSV_VERSION_ATLEAST(1, 9)
221 case AV_PIX_FMT_X2RGB10:206 case AV_PIX_FMT_X2RGB10:
222 *fourcc = MFX_FOURCC_A2RGB10;207 *fourcc = MFX_FOURCC_A2RGB10;
223 return AV_PIX_FMT_X2RGB10;208 return AV_PIX_FMT_X2RGB10;
224#endif
225#if QSV_VERSION_ATLEAST(1, 17)
226 case AV_PIX_FMT_BGRA:209 case AV_PIX_FMT_BGRA:
227 *fourcc = MFX_FOURCC_RGB4;210 *fourcc = MFX_FOURCC_RGB4;
228 return AV_PIX_FMT_BGRA;211 return AV_PIX_FMT_BGRA;
229#endif
230#if CONFIG_VAAPI212#if CONFIG_VAAPI
231 case AV_PIX_FMT_YUV422P:213 case AV_PIX_FMT_YUV422P:
232 case AV_PIX_FMT_YUYV422:214 case AV_PIX_FMT_YUYV422:
233 *fourcc = MFX_FOURCC_YUY2;215 *fourcc = MFX_FOURCC_YUY2;
234 return AV_PIX_FMT_YUYV422;216 return AV_PIX_FMT_YUYV422;
235#if QSV_VERSION_ATLEAST(1, 27)
236 case AV_PIX_FMT_YUV422P10:217 case AV_PIX_FMT_YUV422P10:
237 case AV_PIX_FMT_Y210:218 case AV_PIX_FMT_Y210:
238 *fourcc = MFX_FOURCC_Y210;219 *fourcc = MFX_FOURCC_Y210;
239 return AV_PIX_FMT_Y210;220 return AV_PIX_FMT_Y210;
240#endif
241#endif221#endif
242 default:222 default:
243 return AVERROR(ENOSYS);223 return AVERROR(ENOSYS);
@@ -438,9 +418,7 @@ int ff_qsv_init_internal_session(AVCodecContext *avctx, QSVSession *qs, · 194 unmodified lines
438 const char *desc;418 const char *desc;
439 int ret;419 int ret;
440 420
441#if QSV_VERSION_ATLEAST(1, 16)
442 init_par.GPUCopy = gpu_copy;421 init_par.GPUCopy = gpu_copy;
443#endif
444 init_par.Implementation = impl;422 init_par.Implementation = impl;
445 init_par.Version = ver;423 init_par.Version = ver;
446 ret = MFXInitEx(init_par, &qs->session);424 ret = MFXInitEx(init_par, &qs->session);
@@ -791,9 +769,7 @@ int ff_qsv_init_session_device(AVCodecContext *avctx, mfxSession *psession, · 344 unmodified lines
791 "from the session\n");769 "from the session\n");
792 }770 }
793 771
794#if QSV_VERSION_ATLEAST(1, 16)
795 init_par.GPUCopy = gpu_copy;772 init_par.GPUCopy = gpu_copy;
796#endif
797 init_par.Implementation = impl;773 init_par.Implementation = impl;
798 init_par.Version = ver;774 init_par.Version = ver;
799 err = MFXInitEx(init_par, &session);775 err = MFXInitEx(init_par, &session);
libavcodec/qsvenc.c+168−308
@@ -53,14 +53,10 @@ static const struct profile_names avc_profiles[] = { · 52 unmodified lines
53 { MFX_PROFILE_AVC_MAIN, "avc main" },53 { MFX_PROFILE_AVC_MAIN, "avc main" },
54 { MFX_PROFILE_AVC_EXTENDED, "avc extended" },54 { MFX_PROFILE_AVC_EXTENDED, "avc extended" },
55 { MFX_PROFILE_AVC_HIGH, "avc high" },55 { MFX_PROFILE_AVC_HIGH, "avc high" },
56#if QSV_VERSION_ATLEAST(1, 15)
57 { MFX_PROFILE_AVC_HIGH_422, "avc high 422" },56 { MFX_PROFILE_AVC_HIGH_422, "avc high 422" },
58#endif
59#if QSV_VERSION_ATLEAST(1, 4)
60 { MFX_PROFILE_AVC_CONSTRAINED_BASELINE, "avc constrained baseline" },57 { MFX_PROFILE_AVC_CONSTRAINED_BASELINE, "avc constrained baseline" },
61 { MFX_PROFILE_AVC_CONSTRAINED_HIGH, "avc constrained high" },58 { MFX_PROFILE_AVC_CONSTRAINED_HIGH, "avc constrained high" },
62 { MFX_PROFILE_AVC_PROGRESSIVE_HIGH, "avc progressive high" },59 { MFX_PROFILE_AVC_PROGRESSIVE_HIGH, "avc progressive high" },
63#endif
64};60};
65 61
66static const struct profile_names mpeg2_profiles[] = {62static const struct profile_names mpeg2_profiles[] = {
@@ -70,24 +66,20 @@ static const struct profile_names mpeg2_profiles[] = { · 3 unmodified lines
70};66};
71 67
72static const struct profile_names hevc_profiles[] = {68static const struct profile_names hevc_profiles[] = {
73#if QSV_VERSION_ATLEAST(1, 8)
74 { MFX_PROFILE_HEVC_MAIN, "hevc main" },69 { MFX_PROFILE_HEVC_MAIN, "hevc main" },
75 { MFX_PROFILE_HEVC_MAIN10, "hevc main10" },70 { MFX_PROFILE_HEVC_MAIN10, "hevc main10" },
76 { MFX_PROFILE_HEVC_MAINSP, "hevc mainsp" },71 { MFX_PROFILE_HEVC_MAINSP, "hevc mainsp" },
77 { MFX_PROFILE_HEVC_REXT, "hevc rext" },72 { MFX_PROFILE_HEVC_REXT, "hevc rext" },
78#endif
79#if QSV_VERSION_ATLEAST(1, 32)73#if QSV_VERSION_ATLEAST(1, 32)
80 { MFX_PROFILE_HEVC_SCC, "hevc scc" },74 { MFX_PROFILE_HEVC_SCC, "hevc scc" },
81#endif75#endif
82};76};
83 77
84static const struct profile_names vp9_profiles[] = {78static const struct profile_names vp9_profiles[] = {
85#if QSV_VERSION_ATLEAST(1, 19)
86 { MFX_PROFILE_VP9_0, "vp9 0" },79 { MFX_PROFILE_VP9_0, "vp9 0" },
87 { MFX_PROFILE_VP9_1, "vp9 1" },80 { MFX_PROFILE_VP9_1, "vp9 1" },
88 { MFX_PROFILE_VP9_2, "vp9 2" },81 { MFX_PROFILE_VP9_2, "vp9 2" },
89 { MFX_PROFILE_VP9_3, "vp9 3" },82 { MFX_PROFILE_VP9_3, "vp9 3" },
90#endif
91};83};
92 84
93typedef struct QSVPacket {85typedef struct QSVPacket {
@@ -143,25 +135,15 @@ static const struct { · 49 unmodified lines
143#if QSV_HAVE_AVBR135#if QSV_HAVE_AVBR
144 { MFX_RATECONTROL_AVBR, "AVBR" },136 { MFX_RATECONTROL_AVBR, "AVBR" },
145#endif137#endif
146#if QSV_HAVE_LA
147 { MFX_RATECONTROL_LA, "LA" },138 { MFX_RATECONTROL_LA, "LA" },
148#endif
149#if QSV_HAVE_ICQ
150 { MFX_RATECONTROL_ICQ, "ICQ" },139 { MFX_RATECONTROL_ICQ, "ICQ" },
151 { MFX_RATECONTROL_LA_ICQ, "LA_ICQ" },140 { MFX_RATECONTROL_LA_ICQ, "LA_ICQ" },
152#endif
153#if QSV_HAVE_VCM141#if QSV_HAVE_VCM
154 { MFX_RATECONTROL_VCM, "VCM" },142 { MFX_RATECONTROL_VCM, "VCM" },
155#endif143#endif
156#if QSV_VERSION_ATLEAST(1, 10)
157 { MFX_RATECONTROL_LA_EXT, "LA_EXT" },144 { MFX_RATECONTROL_LA_EXT, "LA_EXT" },
158#endif
159#if QSV_HAVE_LA_HRD
160 { MFX_RATECONTROL_LA_HRD, "LA_HRD" },145 { MFX_RATECONTROL_LA_HRD, "LA_HRD" },
161#endif
162#if QSV_HAVE_QVBR
163 { MFX_RATECONTROL_QVBR, "QVBR" },146 { MFX_RATECONTROL_QVBR, "QVBR" },
164#endif
165};147};
166 148
167static const char *print_ratecontrol(mfxU16 rc_mode)149static const char *print_ratecontrol(mfxU16 rc_mode)
@@ -187,16 +169,20 @@ static void dump_video_param(AVCodecContext *avctx, QSVEncContext *q, · 19 unmodified lines
187{169{
188 mfxInfoMFX *info = &q->param.mfx;170 mfxInfoMFX *info = &q->param.mfx;
189 171
190 mfxExtCodingOption *co = (mfxExtCodingOption*)coding_opts[0];172 // co is always at index 1
191#if QSV_HAVE_CO2173 mfxExtCodingOption *co = (mfxExtCodingOption*)coding_opts[1];
192 mfxExtCodingOption2 *co2 = (mfxExtCodingOption2*)coding_opts[1];174 mfxExtCodingOption2 *co2 = NULL;
193#endif175 mfxExtCodingOption3 *co3 = NULL;
194#if QSV_HAVE_CO3176 mfxExtHEVCTiles *exthevctiles = NULL;
195 mfxExtCodingOption3 *co3 = (mfxExtCodingOption3*)coding_opts[2];177
196#endif178 if (q->co2_idx > 0)
197#if QSV_HAVE_EXT_HEVC_TILES179 co2 = (mfxExtCodingOption2*)coding_opts[q->co2_idx];
198 mfxExtHEVCTiles *exthevctiles = (mfxExtHEVCTiles *)coding_opts[3 + QSV_HAVE_CO_VPS];180
199#endif181 if (q->co3_idx > 0)
182 co3 = (mfxExtCodingOption3*)coding_opts[q->co3_idx];
183
184 if (q->exthevctiles_idx > 0)
185 exthevctiles = (mfxExtHEVCTiles *)coding_opts[q->exthevctiles_idx];
200 186
201 av_log(avctx, AV_LOG_VERBOSE, "profile: %s; level: %"PRIu16"\n",187 av_log(avctx, AV_LOG_VERBOSE, "profile: %s; level: %"PRIu16"\n",
202 print_profile(avctx->codec_id, info->CodecProfile), info->CodecLevel);188 print_profile(avctx->codec_id, info->CodecProfile), info->CodecLevel);
@@ -221,11 +207,6 @@ static void dump_video_param(AVCodecContext *avctx, QSVEncContext *q, · 18 unmodified lines
221 av_log(avctx, AV_LOG_VERBOSE,207 av_log(avctx, AV_LOG_VERBOSE,
222 "BufferSizeInKB: %"PRIu16"; InitialDelayInKB: %"PRIu16"; TargetKbps: %"PRIu16"; MaxKbps: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",208 "BufferSizeInKB: %"PRIu16"; InitialDelayInKB: %"PRIu16"; TargetKbps: %"PRIu16"; MaxKbps: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
223 info->BufferSizeInKB, info->InitialDelayInKB, info->TargetKbps, info->MaxKbps, info->BRCParamMultiplier);209 info->BufferSizeInKB, info->InitialDelayInKB, info->TargetKbps, info->MaxKbps, info->BRCParamMultiplier);
224#if QSV_HAVE_LA
225 if (info->RateControlMethod == MFX_RATECONTROL_VBR && q->extbrc && q->look_ahead_depth > 0 ) {
226 av_log(avctx, AV_LOG_VERBOSE, "LookAheadDepth: %"PRIu16"\n",co2->LookAheadDepth);
227 }
228#endif
229 } else if (info->RateControlMethod == MFX_RATECONTROL_CQP) {210 } else if (info->RateControlMethod == MFX_RATECONTROL_CQP) {
230 av_log(avctx, AV_LOG_VERBOSE, "QPI: %"PRIu16"; QPP: %"PRIu16"; QPB: %"PRIu16"\n",211 av_log(avctx, AV_LOG_VERBOSE, "QPI: %"PRIu16"; QPP: %"PRIu16"; QPB: %"PRIu16"\n",
231 info->QPI, info->QPP, info->QPB);212 info->QPI, info->QPP, info->QPB);
@@ -237,117 +218,22 @@ static void dump_video_param(AVCodecContext *avctx, QSVEncContext *q, · 5 unmodified lines
237 info->TargetKbps, info->Accuracy, info->Convergence, info->BRCParamMultiplier);218 info->TargetKbps, info->Accuracy, info->Convergence, info->BRCParamMultiplier);
238 }219 }
239#endif220#endif
240#if QSV_HAVE_LA
241 else if (info->RateControlMethod == MFX_RATECONTROL_LA221 else if (info->RateControlMethod == MFX_RATECONTROL_LA
242#if QSV_HAVE_LA_HRD
243 || info->RateControlMethod == MFX_RATECONTROL_LA_HRD222 || info->RateControlMethod == MFX_RATECONTROL_LA_HRD
244#endif
245 ) {223 ) {
246 av_log(avctx, AV_LOG_VERBOSE,224 av_log(avctx, AV_LOG_VERBOSE,
247 "TargetKbps: %"PRIu16"; LookAheadDepth: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",225 "TargetKbps: %"PRIu16"; BRCParamMultiplier: %"PRIu16"\n",
248 info->TargetKbps, co2->LookAheadDepth, info->BRCParamMultiplier);226 info->TargetKbps, info->BRCParamMultiplier);
249 }227 } else if (info->RateControlMethod == MFX_RATECONTROL_ICQ ||
250#endif228 info->RateControlMethod == MFX_RATECONTROL_LA_ICQ)
251#if QSV_HAVE_ICQ
252 else if (info->RateControlMethod == MFX_RATECONTROL_ICQ) {
253 av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"\n", info->ICQQuality);229 av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"\n", info->ICQQuality);
254 } else if (info->RateControlMethod == MFX_RATECONTROL_LA_ICQ) {
255 av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"; LookAheadDepth: %"PRIu16"\n",
256 info->ICQQuality, co2->LookAheadDepth);
257 }
258#endif
259#if QSV_HAVE_QVBR
260 else if (info->RateControlMethod == MFX_RATECONTROL_QVBR) {
261 av_log(avctx, AV_LOG_VERBOSE, "QVBRQuality: %"PRIu16"\n",
262 co3->QVBRQuality);
263 }
264#endif
265 av_log(avctx, AV_LOG_VERBOSE, "NumSlice: %"PRIu16"; NumRefFrame: %"PRIu16"\n",230 av_log(avctx, AV_LOG_VERBOSE, "NumSlice: %"PRIu16"; NumRefFrame: %"PRIu16"\n",
266 info->NumSlice, info->NumRefFrame);231 info->NumSlice, info->NumRefFrame);
267 av_log(avctx, AV_LOG_VERBOSE, "RateDistortionOpt: %s\n",232 av_log(avctx, AV_LOG_VERBOSE, "RateDistortionOpt: %s\n",
268 print_threestate(co->RateDistortionOpt));233 print_threestate(co->RateDistortionOpt));
269 234
270#if QSV_HAVE_EXT_HEVC_TILES235 av_log(avctx, AV_LOG_VERBOSE, "RecoveryPointSEI: %s\n", print_threestate(co->RecoveryPointSEI));
271 if (avctx->codec_id == AV_CODEC_ID_HEVC)
272 av_log(avctx, AV_LOG_VERBOSE, "NumTileColumns: %"PRIu16"; NumTileRows: %"PRIu16"\n",
273 exthevctiles->NumTileColumns, exthevctiles->NumTileRows);
274#endif
275
276#if QSV_HAVE_CO2
277 av_log(avctx, AV_LOG_VERBOSE,
278 "RecoveryPointSEI: %s IntRefType: %"PRIu16"; IntRefCycleSize: %"PRIu16"; IntRefQPDelta: %"PRId16"\n",
279 print_threestate(co->RecoveryPointSEI), co2->IntRefType, co2->IntRefCycleSize, co2->IntRefQPDelta);
280
281 av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %d; ", co2->MaxFrameSize);
282#if QSV_HAVE_MAX_SLICE_SIZE
283 av_log(avctx, AV_LOG_VERBOSE, "MaxSliceSize: %d; ", co2->MaxSliceSize);
284#endif
285 av_log(avctx, AV_LOG_VERBOSE, "\n");
286
287 av_log(avctx, AV_LOG_VERBOSE,
288 "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",
289 print_threestate(co2->BitrateLimit), print_threestate(co2->MBBRC),
290 print_threestate(co2->ExtBRC));
291
292#if QSV_HAVE_TRELLIS
293 av_log(avctx, AV_LOG_VERBOSE, "Trellis: ");
294 if (co2->Trellis & MFX_TRELLIS_OFF) {
295 av_log(avctx, AV_LOG_VERBOSE, "off");
296 } else if (!co2->Trellis) {
297 av_log(avctx, AV_LOG_VERBOSE, "auto");
298 } else {
299 if (co2->Trellis & MFX_TRELLIS_I) av_log(avctx, AV_LOG_VERBOSE, "I");
300 if (co2->Trellis & MFX_TRELLIS_P) av_log(avctx, AV_LOG_VERBOSE, "P");
301 if (co2->Trellis & MFX_TRELLIS_B) av_log(avctx, AV_LOG_VERBOSE, "B");
302 }
303 av_log(avctx, AV_LOG_VERBOSE, "\n");
304#endif
305
306#if QSV_HAVE_VDENC
307 av_log(avctx, AV_LOG_VERBOSE, "VDENC: %s\n", print_threestate(info->LowPower));236 av_log(avctx, AV_LOG_VERBOSE, "VDENC: %s\n", print_threestate(info->LowPower));
308#endif
309
310#if QSV_VERSION_ATLEAST(1, 8)
311 av_log(avctx, AV_LOG_VERBOSE,
312 "RepeatPPS: %s; NumMbPerSlice: %"PRIu16"; LookAheadDS: ",
313 print_threestate(co2->RepeatPPS), co2->NumMbPerSlice);
314 switch (co2->LookAheadDS) {
315 case MFX_LOOKAHEAD_DS_OFF: av_log(avctx, AV_LOG_VERBOSE, "off"); break;
316 case MFX_LOOKAHEAD_DS_2x: av_log(avctx, AV_LOG_VERBOSE, "2x"); break;
317 case MFX_LOOKAHEAD_DS_4x: av_log(avctx, AV_LOG_VERBOSE, "4x"); break;
318 default: av_log(avctx, AV_LOG_VERBOSE, "unknown"); break;
319 }
320 av_log(avctx, AV_LOG_VERBOSE, "\n");
321
322 av_log(avctx, AV_LOG_VERBOSE, "AdaptiveI: %s; AdaptiveB: %s; BRefType: ",
323 print_threestate(co2->AdaptiveI), print_threestate(co2->AdaptiveB));
324 switch (co2->BRefType) {
325 case MFX_B_REF_OFF: av_log(avctx, AV_LOG_VERBOSE, "off"); break;
326 case MFX_B_REF_PYRAMID: av_log(avctx, AV_LOG_VERBOSE, "pyramid"); break;
327 default: av_log(avctx, AV_LOG_VERBOSE, "auto"); break;
328 }
329
330 av_log(avctx, AV_LOG_VERBOSE, "; PRefType: ");
331 switch (co3->PRefType) {
332 case MFX_P_REF_DEFAULT: av_log(avctx, AV_LOG_VERBOSE, "default"); break;
333 case MFX_P_REF_SIMPLE: av_log(avctx, AV_LOG_VERBOSE, "simple"); break;
334 case MFX_P_REF_PYRAMID: av_log(avctx, AV_LOG_VERBOSE, "pyramid"); break;
335 default: av_log(avctx, AV_LOG_VERBOSE, "unknown"); break;
336 }
337 av_log(avctx, AV_LOG_VERBOSE, "\n");
338#endif
339
340#if QSV_VERSION_ATLEAST(1, 9)
341 av_log(avctx, AV_LOG_VERBOSE,
342 "MinQPI: %"PRIu8"; MaxQPI: %"PRIu8"; MinQPP: %"PRIu8"; MaxQPP: %"PRIu8"; MinQPB: %"PRIu8"; MaxQPB: %"PRIu8"\n",
343 co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);
344#endif
345#endif
346
347#if QSV_HAVE_GPB
348 if (avctx->codec_id == AV_CODEC_ID_HEVC)
349 av_log(avctx, AV_LOG_VERBOSE,"GPB: %s\n", print_threestate(co3->GPB));
350#endif
351 237
352 if (avctx->codec_id == AV_CODEC_ID_H264) {238 if (avctx->codec_id == AV_CODEC_ID_H264) {
353 av_log(avctx, AV_LOG_VERBOSE, "Entropy coding: %s; MaxDecFrameBuffering: %"PRIu16"\n",239 av_log(avctx, AV_LOG_VERBOSE, "Entropy coding: %s; MaxDecFrameBuffering: %"PRIu16"\n",
@@ -365,36 +251,103 @@ static void dump_video_param(AVCodecContext *avctx, QSVEncContext *q, · 11 unmodified lines
365 av_log(avctx, AV_LOG_VERBOSE, "FrameRateExtD: %"PRIu32"; FrameRateExtN: %"PRIu32" \n",251 av_log(avctx, AV_LOG_VERBOSE, "FrameRateExtD: %"PRIu32"; FrameRateExtN: %"PRIu32" \n",
366 info->FrameInfo.FrameRateExtD, info->FrameInfo.FrameRateExtN);252 info->FrameInfo.FrameRateExtD, info->FrameInfo.FrameRateExtN);
367 253
368#if QSV_HAVE_DISABLEDEBLOCKIDC254 if (co2) {
369 av_log(avctx, AV_LOG_VERBOSE, "DisableDeblockingIdc: %"PRIu32" \n", co2->DisableDeblockingIdc);255 if ((info->RateControlMethod == MFX_RATECONTROL_VBR && q->extbrc && q->look_ahead_depth > 0) ||
370#endif256 (info->RateControlMethod == MFX_RATECONTROL_LA) ||
257 (info->RateControlMethod == MFX_RATECONTROL_LA_HRD) ||
258 (info->RateControlMethod == MFX_RATECONTROL_LA_ICQ))
259 av_log(avctx, AV_LOG_VERBOSE, "LookAheadDepth: %"PRIu16"\n", co2->LookAheadDepth);
371 260
372#if QSV_VERSION_ATLEAST(1, 26)261 av_log(avctx, AV_LOG_VERBOSE, "IntRefType: %"PRIu16"; IntRefCycleSize: %"PRIu16"; IntRefQPDelta: %"PRId16"\n",
373 av_log(avctx, AV_LOG_VERBOSE, "TransformSkip: %s \n", print_threestate(co3->TransformSkip));262 co2->IntRefType, co2->IntRefCycleSize, co2->IntRefQPDelta);
374#endif
375 263
376#if QSV_VERSION_ATLEAST(1, 16)264 av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %d; ", co2->MaxFrameSize);
377 av_log(avctx, AV_LOG_VERBOSE, "IntRefCycleDist: %"PRId16"\n", co3->IntRefCycleDist);265 av_log(avctx, AV_LOG_VERBOSE, "MaxSliceSize: %d; ", co2->MaxSliceSize);
378#endif266 av_log(avctx, AV_LOG_VERBOSE, "\n");
379#if QSV_VERSION_ATLEAST(1, 23)267
380 av_log(avctx, AV_LOG_VERBOSE, "LowDelayBRC: %s\n", print_threestate(co3->LowDelayBRC));268 av_log(avctx, AV_LOG_VERBOSE,
381#endif269 "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",
382#if QSV_VERSION_ATLEAST(1, 19)270 print_threestate(co2->BitrateLimit), print_threestate(co2->MBBRC),
383 av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSizeI: %d; ", co3->MaxFrameSizeI);271 print_threestate(co2->ExtBRC));
384 av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSizeP: %d\n", co3->MaxFrameSizeP);272
385#endif273 av_log(avctx, AV_LOG_VERBOSE, "Trellis: ");
274 if (co2->Trellis & MFX_TRELLIS_OFF) {
275 av_log(avctx, AV_LOG_VERBOSE, "off");
276 } else if (!co2->Trellis) {
277 av_log(avctx, AV_LOG_VERBOSE, "auto");
278 } else {
279 if (co2->Trellis & MFX_TRELLIS_I) av_log(avctx, AV_LOG_VERBOSE, "I");
280 if (co2->Trellis & MFX_TRELLIS_P) av_log(avctx, AV_LOG_VERBOSE, "P");
281 if (co2->Trellis & MFX_TRELLIS_B) av_log(avctx, AV_LOG_VERBOSE, "B");
282 }
283 av_log(avctx, AV_LOG_VERBOSE, "\n");
284
285 av_log(avctx, AV_LOG_VERBOSE,
286 "RepeatPPS: %s; NumMbPerSlice: %"PRIu16"; LookAheadDS: ",
287 print_threestate(co2->RepeatPPS), co2->NumMbPerSlice);
288 switch (co2->LookAheadDS) {
289 case MFX_LOOKAHEAD_DS_OFF: av_log(avctx, AV_LOG_VERBOSE, "off"); break;
290 case MFX_LOOKAHEAD_DS_2x: av_log(avctx, AV_LOG_VERBOSE, "2x"); break;
291 case MFX_LOOKAHEAD_DS_4x: av_log(avctx, AV_LOG_VERBOSE, "4x"); break;
292 default: av_log(avctx, AV_LOG_VERBOSE, "unknown"); break;
293 }
294 av_log(avctx, AV_LOG_VERBOSE, "\n");
295
296 av_log(avctx, AV_LOG_VERBOSE, "AdaptiveI: %s; AdaptiveB: %s; BRefType: ",
297 print_threestate(co2->AdaptiveI), print_threestate(co2->AdaptiveB));
298 switch (co2->BRefType) {
299 case MFX_B_REF_OFF: av_log(avctx, AV_LOG_VERBOSE, "off"); break;
300 case MFX_B_REF_PYRAMID: av_log(avctx, AV_LOG_VERBOSE, "pyramid"); break;
301 default: av_log(avctx, AV_LOG_VERBOSE, "auto"); break;
302 }
303
304 av_log(avctx, AV_LOG_VERBOSE,
305 "MinQPI: %"PRIu8"; MaxQPI: %"PRIu8"; MinQPP: %"PRIu8"; MaxQPP: %"PRIu8"; MinQPB: %"PRIu8"; MaxQPB: %"PRIu8"\n",
306 co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);
307 av_log(avctx, AV_LOG_VERBOSE, "DisableDeblockingIdc: %"PRIu32" \n", co2->DisableDeblockingIdc);
308 }
309
310 if (co3) {
311 if (info->RateControlMethod == MFX_RATECONTROL_QVBR)
312 av_log(avctx, AV_LOG_VERBOSE, "QVBRQuality: %"PRIu16"\n", co3->QVBRQuality);
313
314 av_log(avctx, AV_LOG_VERBOSE, "PRefType: ");
315 switch (co3->PRefType) {
316 case MFX_P_REF_DEFAULT: av_log(avctx, AV_LOG_VERBOSE, "default"); break;
317 case MFX_P_REF_SIMPLE: av_log(avctx, AV_LOG_VERBOSE, "simple"); break;
318 case MFX_P_REF_PYRAMID: av_log(avctx, AV_LOG_VERBOSE, "pyramid"); break;
319 default: av_log(avctx, AV_LOG_VERBOSE, "unknown"); break;
320 }
321 av_log(avctx, AV_LOG_VERBOSE, "\n");
322
323 if (avctx->codec_id == AV_CODEC_ID_HEVC)
324 av_log(avctx, AV_LOG_VERBOSE,"GPB: %s\n", print_threestate(co3->GPB));
325
326 av_log(avctx, AV_LOG_VERBOSE, "TransformSkip: %s \n", print_threestate(co3->TransformSkip));
327 av_log(avctx, AV_LOG_VERBOSE, "IntRefCycleDist: %"PRId16"\n", co3->IntRefCycleDist);
328 av_log(avctx, AV_LOG_VERBOSE, "LowDelayBRC: %s\n", print_threestate(co3->LowDelayBRC));
329 av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSizeI: %d; ", co3->MaxFrameSizeI);
330 av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSizeP: %d\n", co3->MaxFrameSizeP);
331 }
332
333 if (exthevctiles) {
334 av_log(avctx, AV_LOG_VERBOSE, "NumTileColumns: %"PRIu16"; NumTileRows: %"PRIu16"\n",
335 exthevctiles->NumTileColumns, exthevctiles->NumTileRows);
336 }
386}337}
387 338
388static void dump_video_vp9_param(AVCodecContext *avctx, QSVEncContext *q,339static void dump_video_vp9_param(AVCodecContext *avctx, QSVEncContext *q,
389 mfxExtBuffer **coding_opts)340 mfxExtBuffer **coding_opts)
390{341{
391 mfxInfoMFX *info = &q->param.mfx;342 mfxInfoMFX *info = &q->param.mfx;
392#if QSV_HAVE_EXT_VP9_PARAM343 mfxExtVP9Param *vp9_param = NULL;
393 mfxExtVP9Param *vp9_param = (mfxExtVP9Param *)coding_opts[0];344 mfxExtCodingOption2 *co2 = NULL;
394#endif345
395#if QSV_HAVE_CO2346 if (q->vp9_idx >= 0)
396 mfxExtCodingOption2 *co2 = (mfxExtCodingOption2*)coding_opts[1];347 vp9_param = (mfxExtVP9Param *)coding_opts[q->vp9_idx];
397#endif348
349 if (q->co2_idx >= 0)
350 co2 = (mfxExtCodingOption2*)coding_opts[q->co2_idx];
398 351
399 av_log(avctx, AV_LOG_VERBOSE, "profile: %s \n",352 av_log(avctx, AV_LOG_VERBOSE, "profile: %s \n",
400 print_profile(avctx->codec_id, info->CodecProfile));353 print_profile(avctx->codec_id, info->CodecProfile));
@@ -419,48 +372,41 @@ static void dump_video_vp9_param(AVCodecContext *avctx, QSVEncContext *q, · 18 unmodified lines
419 av_log(avctx, AV_LOG_VERBOSE, "QPI: %"PRIu16"; QPP: %"PRIu16"; QPB: %"PRIu16"\n",372 av_log(avctx, AV_LOG_VERBOSE, "QPI: %"PRIu16"; QPP: %"PRIu16"; QPB: %"PRIu16"\n",
420 info->QPI, info->QPP, info->QPB);373 info->QPI, info->QPP, info->QPB);
421 }374 }
422#if QSV_HAVE_ICQ
423 else if (info->RateControlMethod == MFX_RATECONTROL_ICQ) {375 else if (info->RateControlMethod == MFX_RATECONTROL_ICQ) {
424 av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"\n", info->ICQQuality);376 av_log(avctx, AV_LOG_VERBOSE, "ICQQuality: %"PRIu16"\n", info->ICQQuality);
425 }377 }
426#endif
427 else {378 else {
428 av_log(avctx, AV_LOG_VERBOSE, "Unsupported ratecontrol method: %d \n", info->RateControlMethod);379 av_log(avctx, AV_LOG_VERBOSE, "Unsupported ratecontrol method: %d \n", info->RateControlMethod);
429 }380 }
430 381
431 av_log(avctx, AV_LOG_VERBOSE, "NumRefFrame: %"PRIu16"\n", info->NumRefFrame);382 av_log(avctx, AV_LOG_VERBOSE, "NumRefFrame: %"PRIu16"\n", info->NumRefFrame);
383 av_log(avctx, AV_LOG_VERBOSE, "FrameRateExtD: %"PRIu32"; FrameRateExtN: %"PRIu32" \n",
384 info->FrameInfo.FrameRateExtD, info->FrameInfo.FrameRateExtN);
432 385
433#if QSV_HAVE_CO2386 if (co2) {
434 av_log(avctx, AV_LOG_VERBOSE,387 av_log(avctx, AV_LOG_VERBOSE,
435 "IntRefType: %"PRIu16"; IntRefCycleSize: %"PRIu16"; IntRefQPDelta: %"PRId16"\n",388 "IntRefType: %"PRIu16"; IntRefCycleSize: %"PRIu16"; IntRefQPDelta: %"PRId16"\n",
436 co2->IntRefType, co2->IntRefCycleSize, co2->IntRefQPDelta);389 co2->IntRefType, co2->IntRefCycleSize, co2->IntRefQPDelta);
437 390
438 av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %d; ", co2->MaxFrameSize);391 av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %d; ", co2->MaxFrameSize);
439 av_log(avctx, AV_LOG_VERBOSE, "\n");392 av_log(avctx, AV_LOG_VERBOSE, "\n");
440 393
441 av_log(avctx, AV_LOG_VERBOSE,394 av_log(avctx, AV_LOG_VERBOSE,
442 "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",395 "BitrateLimit: %s; MBBRC: %s; ExtBRC: %s\n",
443 print_threestate(co2->BitrateLimit), print_threestate(co2->MBBRC),396 print_threestate(co2->BitrateLimit), print_threestate(co2->MBBRC),
444 print_threestate(co2->ExtBRC));397 print_threestate(co2->ExtBRC));
445 398
446#if QSV_HAVE_VDENC399 av_log(avctx, AV_LOG_VERBOSE, "VDENC: %s\n", print_threestate(info->LowPower));
447 av_log(avctx, AV_LOG_VERBOSE, "VDENC: %s\n", print_threestate(info->LowPower));
448#endif
449 400
450#if QSV_VERSION_ATLEAST(1, 9)401 av_log(avctx, AV_LOG_VERBOSE,
451 av_log(avctx, AV_LOG_VERBOSE,402 "MinQPI: %"PRIu8"; MaxQPI: %"PRIu8"; MinQPP: %"PRIu8"; MaxQPP: %"PRIu8"; MinQPB: %"PRIu8"; MaxQPB: %"PRIu8"\n",
452 "MinQPI: %"PRIu8"; MaxQPI: %"PRIu8"; MinQPP: %"PRIu8"; MaxQPP: %"PRIu8"; MinQPB: %"PRIu8"; MaxQPB: %"PRIu8"\n",403 co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);
453 co2->MinQPI, co2->MaxQPI, co2->MinQPP, co2->MaxQPP, co2->MinQPB, co2->MaxQPB);404 }
454#endif
455#endif
456
457 av_log(avctx, AV_LOG_VERBOSE, "FrameRateExtD: %"PRIu32"; FrameRateExtN: %"PRIu32" \n",
458 info->FrameInfo.FrameRateExtD, info->FrameInfo.FrameRateExtN);
459 405
460#if QSV_HAVE_EXT_VP9_PARAM406 if (vp9_param) {
461 av_log(avctx, AV_LOG_VERBOSE, "WriteIVFHeaders: %s \n",407 av_log(avctx, AV_LOG_VERBOSE, "WriteIVFHeaders: %s \n",
462 print_threestate(vp9_param->WriteIVFHeaders));408 print_threestate(vp9_param->WriteIVFHeaders));
463#endif409 }
464}410}
465 411
466static void dump_video_mjpeg_param(AVCodecContext *avctx, QSVEncContext *q)412static void dump_video_mjpeg_param(AVCodecContext *avctx, QSVEncContext *q)
@@ -484,11 +430,6 @@ static int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q) · 17 unmodified lines
484 int want_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);430 int want_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
485 int want_vcm = q->vcm;431 int want_vcm = q->vcm;
486 432
487 if (want_la && !QSV_HAVE_LA) {
488 av_log(avctx, AV_LOG_ERROR,
489 "Lookahead ratecontrol mode requested, but is not supported by this SDK version\n");
490 return AVERROR(ENOSYS);
491 }
492 if (want_vcm && !QSV_HAVE_VCM) {433 if (want_vcm && !QSV_HAVE_VCM) {
493 av_log(avctx, AV_LOG_ERROR,434 av_log(avctx, AV_LOG_ERROR,
494 "VCM ratecontrol mode requested, but is not supported by this SDK version\n");435 "VCM ratecontrol mode requested, but is not supported by this SDK version\n");
@@ -502,12 +443,6 @@ static int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q) · 7 unmodified lines
502 return AVERROR(EINVAL);443 return AVERROR(EINVAL);
503 }444 }
504 445
505 if (!want_qscale && avctx->global_quality > 0 && !QSV_HAVE_ICQ){
506 av_log(avctx, AV_LOG_ERROR,
507 "ICQ ratecontrol mode requested, but is not supported by this SDK version\n");
508 return AVERROR(ENOSYS);
509 }
510
511 if (want_qscale) {446 if (want_qscale) {
512 rc_mode = MFX_RATECONTROL_CQP;447 rc_mode = MFX_RATECONTROL_CQP;
513 rc_desc = "constant quantization parameter (CQP)";448 rc_desc = "constant quantization parameter (CQP)";
@@ -518,25 +453,19 @@ static int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q) · 4 unmodified lines
518 rc_desc = "video conferencing mode (VCM)";453 rc_desc = "video conferencing mode (VCM)";
519 }454 }
520#endif455#endif
521#if QSV_HAVE_LA
522 else if (want_la) {456 else if (want_la) {
523 rc_mode = MFX_RATECONTROL_LA;457 rc_mode = MFX_RATECONTROL_LA;
524 rc_desc = "VBR with lookahead (LA)";458 rc_desc = "VBR with lookahead (LA)";
525 459
526#if QSV_HAVE_ICQ
527 if (avctx->global_quality > 0) {460 if (avctx->global_quality > 0) {
528 rc_mode = MFX_RATECONTROL_LA_ICQ;461 rc_mode = MFX_RATECONTROL_LA_ICQ;
529 rc_desc = "intelligent constant quality with lookahead (LA_ICQ)";462 rc_desc = "intelligent constant quality with lookahead (LA_ICQ)";
530 }463 }
531#endif
532 }464 }
533#endif
534#if QSV_HAVE_ICQ
535 else if (avctx->global_quality > 0 && !avctx->rc_max_rate) {465 else if (avctx->global_quality > 0 && !avctx->rc_max_rate) {
536 rc_mode = MFX_RATECONTROL_ICQ;466 rc_mode = MFX_RATECONTROL_ICQ;
537 rc_desc = "intelligent constant quality (ICQ)";467 rc_desc = "intelligent constant quality (ICQ)";
538 }468 }
539#endif
540 else if (avctx->rc_max_rate == avctx->bit_rate) {469 else if (avctx->rc_max_rate == avctx->bit_rate) {
541 rc_mode = MFX_RATECONTROL_CBR;470 rc_mode = MFX_RATECONTROL_CBR;
542 rc_desc = "constant bitrate (CBR)";471 rc_desc = "constant bitrate (CBR)";
@@ -547,12 +476,10 @@ static int select_rc_mode(AVCodecContext *avctx, QSVEncContext *q) · 4 unmodified lines
547 rc_desc = "average variable bitrate (AVBR)";476 rc_desc = "average variable bitrate (AVBR)";
548 }477 }
549#endif478#endif
550#if QSV_HAVE_QVBR
551 else if (avctx->global_quality > 0) {479 else if (avctx->global_quality > 0) {
552 rc_mode = MFX_RATECONTROL_QVBR;480 rc_mode = MFX_RATECONTROL_QVBR;
553 rc_desc = "constant quality with VBR algorithm (QVBR)";481 rc_desc = "constant quality with VBR algorithm (QVBR)";
554 }482 }
555#endif
556 else {483 else {
557 rc_mode = MFX_RATECONTROL_VBR;484 rc_mode = MFX_RATECONTROL_VBR;
558 rc_desc = "variable bitrate (VBR)";485 rc_desc = "variable bitrate (VBR)";
@@ -692,14 +619,7 @@ static int init_video_param(AVCodecContext *avctx, QSVEncContext *q) · 133 unmodified lines
692 }619 }
693 620
694 if (q->low_power == 1) {621 if (q->low_power == 1) {
695#if QSV_HAVE_VDENC
696 q->param.mfx.LowPower = MFX_CODINGOPTION_ON;622 q->param.mfx.LowPower = MFX_CODINGOPTION_ON;
697#else
698 av_log(avctx, AV_LOG_WARNING, "The low_power option is "
699 "not supported with this MSDK version.\n");
700 q->low_power = 0;
701 q->param.mfx.LowPower = MFX_CODINGOPTION_OFF;
702#endif
703 } else if (q->low_power == -1)623 } else if (q->low_power == -1)
704 q->param.mfx.LowPower = MFX_CODINGOPTION_UNKNOWN;624 q->param.mfx.LowPower = MFX_CODINGOPTION_UNKNOWN;
705 else625 else
@@ -789,26 +709,20 @@ static int init_video_param(AVCodecContext *avctx, QSVEncContext *q) · 83 unmodified lines
789 switch (q->param.mfx.RateControlMethod) {709 switch (q->param.mfx.RateControlMethod) {
790 case MFX_RATECONTROL_CBR:710 case MFX_RATECONTROL_CBR:
791 case MFX_RATECONTROL_VBR:711 case MFX_RATECONTROL_VBR:
792#if QSV_HAVE_LA
793 if (q->extbrc) {712 if (q->extbrc) {
794 q->extco2.LookAheadDepth = q->look_ahead_depth;713 q->extco2.LookAheadDepth = q->look_ahead_depth;
795 }714 }
796#endif
797#if QSV_HAVE_VCM715#if QSV_HAVE_VCM
798 case MFX_RATECONTROL_VCM:716 case MFX_RATECONTROL_VCM:
799#endif717#endif
800#if QSV_HAVE_QVBR
801 case MFX_RATECONTROL_QVBR:718 case MFX_RATECONTROL_QVBR:
802#endif
803 q->param.mfx.BufferSizeInKB = buffer_size_in_kilobytes / brc_param_multiplier;719 q->param.mfx.BufferSizeInKB = buffer_size_in_kilobytes / brc_param_multiplier;
804 q->param.mfx.InitialDelayInKB = initial_delay_in_kilobytes / brc_param_multiplier;720 q->param.mfx.InitialDelayInKB = initial_delay_in_kilobytes / brc_param_multiplier;
805 q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;721 q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
806 q->param.mfx.MaxKbps = max_bitrate_kbps / brc_param_multiplier;722 q->param.mfx.MaxKbps = max_bitrate_kbps / brc_param_multiplier;
807 q->param.mfx.BRCParamMultiplier = brc_param_multiplier;723 q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
808#if QSV_HAVE_QVBR
809 if (q->param.mfx.RateControlMethod == MFX_RATECONTROL_QVBR)724 if (q->param.mfx.RateControlMethod == MFX_RATECONTROL_QVBR)
810 q->extco3.QVBRQuality = av_clip(avctx->global_quality, 0, 51);725 q->extco3.QVBRQuality = av_clip(avctx->global_quality, 0, 51);
811#endif
812 break;726 break;
813 case MFX_RATECONTROL_CQP:727 case MFX_RATECONTROL_CQP:
814 quant = avctx->global_quality / FF_QP2LAMBDA;728 quant = avctx->global_quality / FF_QP2LAMBDA;
@@ -826,20 +740,16 @@ static int init_video_param(AVCodecContext *avctx, QSVEncContext *q) · 11 unmodified lines
826 q->param.mfx.BRCParamMultiplier = brc_param_multiplier;740 q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
827 break;741 break;
828#endif742#endif
829#if QSV_HAVE_LA
830 case MFX_RATECONTROL_LA:743 case MFX_RATECONTROL_LA:
831 q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;744 q->param.mfx.TargetKbps = target_bitrate_kbps / brc_param_multiplier;
832 q->extco2.LookAheadDepth = q->look_ahead_depth;745 q->extco2.LookAheadDepth = q->look_ahead_depth;
833 q->param.mfx.BRCParamMultiplier = brc_param_multiplier;746 q->param.mfx.BRCParamMultiplier = brc_param_multiplier;
834 break;747 break;
835#if QSV_HAVE_ICQ
836 case MFX_RATECONTROL_LA_ICQ:748 case MFX_RATECONTROL_LA_ICQ:
837 q->extco2.LookAheadDepth = q->look_ahead_depth;749 q->extco2.LookAheadDepth = q->look_ahead_depth;
838 case MFX_RATECONTROL_ICQ:750 case MFX_RATECONTROL_ICQ:
839 q->param.mfx.ICQQuality = av_clip(avctx->global_quality, 1, 51);751 q->param.mfx.ICQQuality = av_clip(avctx->global_quality, 1, 51);
840 break;752 break;
841#endif
842#endif
843 }753 }
844 754
845 // The HEVC encoder plugin currently fails with some old libmfx version if coding options755 // The HEVC encoder plugin currently fails with some old libmfx version if coding options
@@ -883,19 +793,15 @@ static int init_video_param(AVCodecContext *avctx, QSVEncContext *q) · 37 unmodified lines
883 793
884 q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco;794 q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco;
885 795
886#if QSV_HAVE_CO2
887 if (avctx->codec_id == AV_CODEC_ID_H264) {796 if (avctx->codec_id == AV_CODEC_ID_H264) {
888 if (q->bitrate_limit >= 0)797 if (q->bitrate_limit >= 0)
889 q->extco2.BitrateLimit = q->bitrate_limit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;798 q->extco2.BitrateLimit = q->bitrate_limit ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
890 799
891#if QSV_HAVE_TRELLIS
892 if (avctx->trellis >= 0)800 if (avctx->trellis >= 0)
893 q->extco2.Trellis = (avctx->trellis == 0) ? MFX_TRELLIS_OFF : (MFX_TRELLIS_I | MFX_TRELLIS_P | MFX_TRELLIS_B);801 q->extco2.Trellis = (avctx->trellis == 0) ? MFX_TRELLIS_OFF : (MFX_TRELLIS_I | MFX_TRELLIS_P | MFX_TRELLIS_B);
894 else802 else
895 q->extco2.Trellis = MFX_TRELLIS_UNKNOWN;803 q->extco2.Trellis = MFX_TRELLIS_UNKNOWN;
896#endif
897 804
898#if QSV_VERSION_ATLEAST(1, 8)
899 q->extco2.LookAheadDS = q->look_ahead_downsampling;805 q->extco2.LookAheadDS = q->look_ahead_downsampling;
900 q->extco2.RepeatPPS = q->repeat_pps ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;806 q->extco2.RepeatPPS = q->repeat_pps ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
901 807
@@ -903,7 +809,6 @@ static int init_video_param(AVCodecContext *avctx, QSVEncContext *q) · 1 unmodified line
903 q->extco2.AdaptiveI = q->adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;809 q->extco2.AdaptiveI = q->adaptive_i ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
904 if (q->adaptive_b >= 0)810 if (q->adaptive_b >= 0)
905 q->extco2.AdaptiveB = q->adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;811 q->extco2.AdaptiveB = q->adaptive_b ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
906#endif
907 }812 }
908 813
909 if (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_HEVC) {814 if (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_HEVC) {
@@ -917,19 +822,12 @@ static int init_video_param(AVCodecContext *avctx, QSVEncContext *q) · 7 unmodified lines
917 q->extco2.IntRefCycleSize = q->int_ref_cycle_size;822 q->extco2.IntRefCycleSize = q->int_ref_cycle_size;
918 if (q->int_ref_qp_delta != INT16_MIN)823 if (q->int_ref_qp_delta != INT16_MIN)
919 q->extco2.IntRefQPDelta = q->int_ref_qp_delta;824 q->extco2.IntRefQPDelta = q->int_ref_qp_delta;
920#if QSV_HAVE_MAX_SLICE_SIZE
921 if (q->max_slice_size >= 0)825 if (q->max_slice_size >= 0)
922 q->extco2.MaxSliceSize = q->max_slice_size;826 q->extco2.MaxSliceSize = q->max_slice_size;
923#endif
924#if QSV_HAVE_DISABLEDEBLOCKIDC
925 q->extco2.DisableDeblockingIdc = q->dblk_idc;827 q->extco2.DisableDeblockingIdc = q->dblk_idc;
926#endif
927 828
928#if QSV_VERSION_ATLEAST(1, 8)
929 if (q->b_strategy >= 0)829 if (q->b_strategy >= 0)
930 q->extco2.BRefType = q->b_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;830 q->extco2.BRefType = q->b_strategy ? MFX_B_REF_PYRAMID : MFX_B_REF_OFF;
931#endif
932#if QSV_VERSION_ATLEAST(1, 9)
933 if (avctx->qmin >= 0 && avctx->qmax >= 0 && avctx->qmin > avctx->qmax) {831 if (avctx->qmin >= 0 && avctx->qmax >= 0 && avctx->qmin > avctx->qmax) {
934 av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are set but invalid, please make sure min <= max\n");832 av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are set but invalid, please make sure min <= max\n");
935 return AVERROR(EINVAL);833 return AVERROR(EINVAL);
@@ -942,7 +840,6 @@ static int init_video_param(AVCodecContext *avctx, QSVEncContext *q) · 6 unmodified lines
942 q->extco2.MaxQPI = avctx->qmax > 51 ? 51 : avctx->qmax;840 q->extco2.MaxQPI = avctx->qmax > 51 ? 51 : avctx->qmax;
943 q->extco2.MaxQPP = q->extco2.MaxQPB = q->extco2.MaxQPI;841 q->extco2.MaxQPP = q->extco2.MaxQPB = q->extco2.MaxQPI;
944 }842 }
945#endif
946 if (q->mbbrc >= 0)843 if (q->mbbrc >= 0)
947 q->extco2.MBBRC = q->mbbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;844 q->extco2.MBBRC = q->mbbrc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
948 845
@@ -951,7 +848,6 @@ static int init_video_param(AVCodecContext *avctx, QSVEncContext *q) · 2 unmodified lines
951 848
952 q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;849 q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco2;
953 }850 }
954#endif
955 851
956 if (avctx->codec_id == AV_CODEC_ID_H264) {852 if (avctx->codec_id == AV_CODEC_ID_H264) {
957#if QSV_HAVE_MF853#if QSV_HAVE_MF
@@ -965,13 +861,11 @@ static int init_video_param(AVCodecContext *avctx, QSVEncContext *q) · 7 unmodified lines
965 }861 }
966#endif862#endif
967 }863 }
968#if QSV_HAVE_CO3
969 q->extco3.Header.BufferId = MFX_EXTBUFF_CODING_OPTION3;864 q->extco3.Header.BufferId = MFX_EXTBUFF_CODING_OPTION3;
970 q->extco3.Header.BufferSz = sizeof(q->extco3);865 q->extco3.Header.BufferSz = sizeof(q->extco3);
971 866
972 if (avctx->codec_id == AV_CODEC_ID_HEVC ||867 if (avctx->codec_id == AV_CODEC_ID_HEVC ||
973 avctx->codec_id == AV_CODEC_ID_H264) {868 avctx->codec_id == AV_CODEC_ID_H264) {
974#if QSV_HAVE_PREF
975 switch (q->p_strategy) {869 switch (q->p_strategy) {
976 case 0:870 case 0:
977 q->extco3.PRefType = MFX_P_REF_DEFAULT;871 q->extco3.PRefType = MFX_P_REF_DEFAULT;
@@ -993,40 +887,27 @@ static int init_video_param(AVCodecContext *avctx, QSVEncContext *q) · 15 unmodified lines
993 av_log(avctx, AV_LOG_WARNING,887 av_log(avctx, AV_LOG_WARNING,
994 "Please set max_b_frames(-bf) to 0 to enable P-pyramid\n");888 "Please set max_b_frames(-bf) to 0 to enable P-pyramid\n");
995 }889 }
996#endif
997#if QSV_VERSION_ATLEAST(1, 16)
998 if (q->int_ref_cycle_dist >= 0)890 if (q->int_ref_cycle_dist >= 0)
999 q->extco3.IntRefCycleDist = q->int_ref_cycle_dist;891 q->extco3.IntRefCycleDist = q->int_ref_cycle_dist;
1000#endif
1001#if QSV_VERSION_ATLEAST(1, 23)
1002 if (q->low_delay_brc >= 0)892 if (q->low_delay_brc >= 0)
1003 q->extco3.LowDelayBRC = q->low_delay_brc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;893 q->extco3.LowDelayBRC = q->low_delay_brc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1004#endif
1005#if QSV_VERSION_ATLEAST(1, 19)
1006 if (q->max_frame_size_i >= 0)894 if (q->max_frame_size_i >= 0)
1007 q->extco3.MaxFrameSizeI = q->max_frame_size_i;895 q->extco3.MaxFrameSizeI = q->max_frame_size_i;
1008 if (q->max_frame_size_p >= 0)896 if (q->max_frame_size_p >= 0)
1009 q->extco3.MaxFrameSizeP = q->max_frame_size_p;897 q->extco3.MaxFrameSizeP = q->max_frame_size_p;
1010#endif
1011 }898 }
1012 899
1013 if (avctx->codec_id == AV_CODEC_ID_HEVC) {900 if (avctx->codec_id == AV_CODEC_ID_HEVC) {
1014#if QSV_VERSION_ATLEAST(1, 26)
1015 if (q->transform_skip >= 0)901 if (q->transform_skip >= 0)
1016 q->extco3.TransformSkip = q->transform_skip ? MFX_CODINGOPTION_ON :902 q->extco3.TransformSkip = q->transform_skip ? MFX_CODINGOPTION_ON :
1017 MFX_CODINGOPTION_OFF;903 MFX_CODINGOPTION_OFF;
1018 else904 else
1019 q->extco3.TransformSkip = MFX_CODINGOPTION_UNKNOWN;905 q->extco3.TransformSkip = MFX_CODINGOPTION_UNKNOWN;
1020#endif
1021#if QSV_HAVE_GPB
1022 q->extco3.GPB = q->gpb ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;906 q->extco3.GPB = q->gpb ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
1023#endif
1024 }907 }
1025 q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco3;908 q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extco3;
1026#endif
1027 }909 }
1028 910
1029#if QSV_HAVE_EXT_VP9_PARAM
1030 if (avctx->codec_id == AV_CODEC_ID_VP9) {911 if (avctx->codec_id == AV_CODEC_ID_VP9) {
1031 q->extvp9param.Header.BufferId = MFX_EXTBUFF_VP9_PARAM;912 q->extvp9param.Header.BufferId = MFX_EXTBUFF_VP9_PARAM;
1032 q->extvp9param.Header.BufferSz = sizeof(q->extvp9param);913 q->extvp9param.Header.BufferSz = sizeof(q->extvp9param);
@@ -1037,9 +918,7 @@ static int init_video_param(AVCodecContext *avctx, QSVEncContext *q) · 4 unmodified lines
1037#endif918#endif
1038 q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extvp9param;919 q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extvp9param;
1039 }920 }
1040#endif
1041 921
1042#if QSV_HAVE_EXT_HEVC_TILES
1043 if (avctx->codec_id == AV_CODEC_ID_HEVC) {922 if (avctx->codec_id == AV_CODEC_ID_HEVC) {
1044 q->exthevctiles.Header.BufferId = MFX_EXTBUFF_HEVC_TILES;923 q->exthevctiles.Header.BufferId = MFX_EXTBUFF_HEVC_TILES;
1045 q->exthevctiles.Header.BufferSz = sizeof(q->exthevctiles);924 q->exthevctiles.Header.BufferSz = sizeof(q->exthevctiles);
@@ -1047,7 +926,6 @@ static int init_video_param(AVCodecContext *avctx, QSVEncContext *q) · 1 unmodified line
1047 q->exthevctiles.NumTileRows = q->tile_rows;926 q->exthevctiles.NumTileRows = q->tile_rows;
1048 q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->exthevctiles;927 q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->exthevctiles;
1049 }928 }
1050#endif
1051 929
1052 q->extvsi.VideoFullRange = (avctx->color_range == AVCOL_RANGE_JPEG);930 q->extvsi.VideoFullRange = (avctx->color_range == AVCOL_RANGE_JPEG);
1053 q->extvsi.ColourDescriptionPresent = 0;931 q->extvsi.ColourDescriptionPresent = 0;
@@ -1100,41 +978,44 @@ static int qsv_retrieve_enc_jpeg_params(AVCodecContext *avctx, QSVEncContext *q) · 46 unmodified lines
1100static int qsv_retrieve_enc_vp9_params(AVCodecContext *avctx, QSVEncContext *q)978static int qsv_retrieve_enc_vp9_params(AVCodecContext *avctx, QSVEncContext *q)
1101{979{
1102 int ret = 0;980 int ret = 0;
1103#if QSV_HAVE_EXT_VP9_PARAM
1104 mfxExtVP9Param vp9_extend_buf = {981 mfxExtVP9Param vp9_extend_buf = {
1105 .Header.BufferId = MFX_EXTBUFF_VP9_PARAM,982 .Header.BufferId = MFX_EXTBUFF_VP9_PARAM,
1106 .Header.BufferSz = sizeof(vp9_extend_buf),983 .Header.BufferSz = sizeof(vp9_extend_buf),
1107 };984 };
1108#endif
1109 985
1110#if QSV_HAVE_CO2
1111 mfxExtCodingOption2 co2 = {986 mfxExtCodingOption2 co2 = {
1112 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,987 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
1113 .Header.BufferSz = sizeof(co2),988 .Header.BufferSz = sizeof(co2),
1114 };989 };
1115#endif
1116 990
1117#if QSV_HAVE_CO3
1118 mfxExtCodingOption3 co3 = {991 mfxExtCodingOption3 co3 = {
1119 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,992 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
1120 .Header.BufferSz = sizeof(co3),993 .Header.BufferSz = sizeof(co3),
1121 };994 };
1122#endif
1123 995
1124 mfxExtBuffer *ext_buffers[] = {996 mfxExtBuffer *ext_buffers[3];
1125#if QSV_HAVE_EXT_VP9_PARAM997 int ext_buf_num = 0;
1126 (mfxExtBuffer*)&vp9_extend_buf,998
1127#endif999 q->co2_idx = q->co3_idx = q->vp9_idx = -1;
1128#if QSV_HAVE_CO21000
1129 (mfxExtBuffer*)&co2,1001 // It is possible the runtime doesn't support the given ext buffer
1130#endif1002 if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 6)) {
1131#if QSV_HAVE_CO31003 q->co2_idx = ext_buf_num;
1132 (mfxExtBuffer*)&co3,1004 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co2;
1133#endif1005 }
1134 };1006
1007 if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 11)) {
1008 q->co3_idx = ext_buf_num;
1009 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co3;
1010 }
1011
1012 if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 26)) {
1013 q->vp9_idx = ext_buf_num;
1014 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&vp9_extend_buf;
1015 }
1135 1016
1136 q->param.ExtParam = ext_buffers;1017 q->param.ExtParam = ext_buffers;
1137 q->param.NumExtParam = FF_ARRAY_ELEMS(ext_buffers);1018 q->param.NumExtParam = ext_buf_num;
1138 1019
1139 ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);1020 ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param);
1140 if (ret < 0)1021 if (ret < 0)
@@ -1166,20 +1047,15 @@ static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q) · 25 unmodified lines
1166 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,1047 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION,
1167 .Header.BufferSz = sizeof(co),1048 .Header.BufferSz = sizeof(co),
1168 };1049 };
1169#if QSV_HAVE_CO2
1170 mfxExtCodingOption2 co2 = {1050 mfxExtCodingOption2 co2 = {
1171 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,1051 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION2,
1172 .Header.BufferSz = sizeof(co2),1052 .Header.BufferSz = sizeof(co2),
1173 };1053 };
1174#endif
1175#if QSV_HAVE_CO3
1176 mfxExtCodingOption3 co3 = {1054 mfxExtCodingOption3 co3 = {
1177 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,1055 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION3,
1178 .Header.BufferSz = sizeof(co3),1056 .Header.BufferSz = sizeof(co3),
1179 };1057 };
1180#endif
1181 1058
1182#if QSV_HAVE_CO_VPS
1183 uint8_t vps_buf[128];1059 uint8_t vps_buf[128];
1184 mfxExtCodingOptionVPS extradata_vps = {1060 mfxExtCodingOptionVPS extradata_vps = {
1185 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_VPS,1061 .Header.BufferId = MFX_EXTBUFF_CODING_OPTION_VPS,
@@ -1187,37 +1063,39 @@ static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q) · 1 unmodified line
1187 .VPSBuffer = vps_buf,1063 .VPSBuffer = vps_buf,
1188 .VPSBufSize = sizeof(vps_buf),1064 .VPSBufSize = sizeof(vps_buf),
1189 };1065 };
1190#endif
1191 1066
1192#if QSV_HAVE_EXT_HEVC_TILES
1193 mfxExtHEVCTiles hevc_tile_buf = {1067 mfxExtHEVCTiles hevc_tile_buf = {
1194 .Header.BufferId = MFX_EXTBUFF_HEVC_TILES,1068 .Header.BufferId = MFX_EXTBUFF_HEVC_TILES,
1195 .Header.BufferSz = sizeof(hevc_tile_buf),1069 .Header.BufferSz = sizeof(hevc_tile_buf),
1196 };1070 };
1197#endif
1198 1071
1199 mfxExtBuffer *ext_buffers[2 + QSV_HAVE_CO2 + QSV_HAVE_CO3 + QSV_HAVE_CO_VPS + QSV_HAVE_EXT_HEVC_TILES];1072 mfxExtBuffer *ext_buffers[6];
1200 1073
1201 int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;1074 int need_pps = avctx->codec_id != AV_CODEC_ID_MPEG2VIDEO;
1202 int ret, ext_buf_num = 0, extradata_offset = 0;1075 int ret, ext_buf_num = 0, extradata_offset = 0;
1203 1076
1077 q->co2_idx = q->co3_idx = q->exthevctiles_idx = -1;
1204 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata;1078 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata;
1205 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co;1079 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co;
1206#if QSV_HAVE_CO21080
1207 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co2;1081 // It is possible the runtime doesn't support the given ext buffer
1208#endif1082 if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 6)) {
1209#if QSV_HAVE_CO31083 q->co2_idx = ext_buf_num;
1210 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co3;1084 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co2;
1211#endif1085 }
1212#if QSV_HAVE_CO_VPS1086
1087 if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 11)) {
1088 q->co3_idx = ext_buf_num;
1089 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&co3;
1090 }
1091
1213 q->hevc_vps = ((avctx->codec_id == AV_CODEC_ID_HEVC) && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 17));1092 q->hevc_vps = ((avctx->codec_id == AV_CODEC_ID_HEVC) && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 17));
1214 if (q->hevc_vps)1093 if (q->hevc_vps)
1215 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata_vps;1094 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&extradata_vps;
1216#endif1095 if (avctx->codec_id == AV_CODEC_ID_HEVC && QSV_RUNTIME_VERSION_ATLEAST(q->ver, 1, 13)) {
1217#if QSV_HAVE_EXT_HEVC_TILES1096 q->exthevctiles_idx = ext_buf_num;
1218 if (avctx->codec_id == AV_CODEC_ID_HEVC)
1219 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&hevc_tile_buf;1097 ext_buffers[ext_buf_num++] = (mfxExtBuffer*)&hevc_tile_buf;
1220#endif1098 }
1221 1099
1222 q->param.ExtParam = ext_buffers;1100 q->param.ExtParam = ext_buffers;
1223 q->param.NumExtParam = ext_buf_num;1101 q->param.NumExtParam = ext_buf_num;
@@ -1230,29 +1108,23 @@ static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q) · 6 unmodified lines
1230 q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;1108 q->packet_size = q->param.mfx.BufferSizeInKB * q->param.mfx.BRCParamMultiplier * 1000;
1231 1109
1232 if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)1110 if (!extradata.SPSBufSize || (need_pps && !extradata.PPSBufSize)
1233#if QSV_HAVE_CO_VPS
1234 || (q->hevc_vps && !extradata_vps.VPSBufSize)1111 || (q->hevc_vps && !extradata_vps.VPSBufSize)
1235#endif
1236 ) {1112 ) {
1237 av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");1113 av_log(avctx, AV_LOG_ERROR, "No extradata returned from libmfx.\n");
1238 return AVERROR_UNKNOWN;1114 return AVERROR_UNKNOWN;
1239 }1115 }
1240 1116
1241 avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;1117 avctx->extradata_size = extradata.SPSBufSize + need_pps * extradata.PPSBufSize;
1242#if QSV_HAVE_CO_VPS
1243 avctx->extradata_size += q->hevc_vps * extradata_vps.VPSBufSize;1118 avctx->extradata_size += q->hevc_vps * extradata_vps.VPSBufSize;
1244#endif
1245 1119
1246 avctx->extradata = av_malloc(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);1120 avctx->extradata = av_malloc(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
1247 if (!avctx->extradata)1121 if (!avctx->extradata)
1248 return AVERROR(ENOMEM);1122 return AVERROR(ENOMEM);
1249 1123
1250#if QSV_HAVE_CO_VPS
1251 if (q->hevc_vps) {1124 if (q->hevc_vps) {
1252 memcpy(avctx->extradata, vps_buf, extradata_vps.VPSBufSize);1125 memcpy(avctx->extradata, vps_buf, extradata_vps.VPSBufSize);
1253 extradata_offset += extradata_vps.VPSBufSize;1126 extradata_offset += extradata_vps.VPSBufSize;
1254 }1127 }
1255#endif
1256 1128
1257 memcpy(avctx->extradata + extradata_offset, sps_buf, extradata.SPSBufSize);1129 memcpy(avctx->extradata + extradata_offset, sps_buf, extradata.SPSBufSize);
1258 extradata_offset += extradata.SPSBufSize;1130 extradata_offset += extradata.SPSBufSize;
@@ -1270,7 +1142,7 @@ static int qsv_retrieve_enc_params(AVCodecContext *avctx, QSVEncContext *q) · 11 unmodified lines
1270 cpb_props->avg_bitrate = avctx->bit_rate;1142 cpb_props->avg_bitrate = avctx->bit_rate;
1271 cpb_props->buffer_size = avctx->rc_buffer_size;1143 cpb_props->buffer_size = avctx->rc_buffer_size;
1272 1144
1273 dump_video_param(avctx, q, ext_buffers + 1);1145 dump_video_param(avctx, q, ext_buffers);
1274 1146
1275 return 0;1147 return 0;
1276}1148}
@@ -1652,10 +1524,8 @@ static int encode_frame(AVCodecContext *avctx, QSVEncContext *q, · 375 unmodified lines
1652 const AVFrame *frame)1524 const AVFrame *frame)
1653{1525{
1654 QSVPacket pkt = { { 0 } };1526 QSVPacket pkt = { { 0 } };
1655#if QSV_VERSION_ATLEAST(1, 26)
1656 mfxExtAVCEncodedFrameInfo *enc_info = NULL;1527 mfxExtAVCEncodedFrameInfo *enc_info = NULL;
1657 mfxExtBuffer **enc_buf = NULL;1528 mfxExtBuffer **enc_buf = NULL;
1658#endif
1659 1529
1660 mfxFrameSurface1 *surf = NULL;1530 mfxFrameSurface1 *surf = NULL;
1661 QSVFrame *qsv_frame = NULL;1531 QSVFrame *qsv_frame = NULL;
@@ -1692,7 +1562,6 @@ static int encode_frame(AVCodecContext *avctx, QSVEncContext *q, · 30 unmodified lines
1692 pkt.bs->Data = pkt.pkt.data;1562 pkt.bs->Data = pkt.pkt.data;
1693 pkt.bs->MaxLength = pkt.pkt.size;1563 pkt.bs->MaxLength = pkt.pkt.size;
1694 1564
1695#if QSV_VERSION_ATLEAST(1, 26)
1696 if (avctx->codec_id == AV_CODEC_ID_H264) {1565 if (avctx->codec_id == AV_CODEC_ID_H264) {
1697 enc_info = av_mallocz(sizeof(*enc_info));1566 enc_info = av_mallocz(sizeof(*enc_info));
1698 if (!enc_info)1567 if (!enc_info)
@@ -1708,7 +1577,6 @@ static int encode_frame(AVCodecContext *avctx, QSVEncContext *q, · 9 unmodified lines
1708 1577
1709 pkt.bs->ExtParam = enc_buf;1578 pkt.bs->ExtParam = enc_buf;
1710 }1579 }
1711#endif
1712 1580
1713 if (q->set_encode_ctrl_cb) {1581 if (q->set_encode_ctrl_cb) {
1714 q->set_encode_ctrl_cb(avctx, frame, &qsv_frame->enc_ctrl);1582 q->set_encode_ctrl_cb(avctx, frame, &qsv_frame->enc_ctrl);
@@ -1745,12 +1613,10 @@ free: · 30 unmodified lines
1745 av_freep(&pkt.sync);1613 av_freep(&pkt.sync);
1746 av_packet_unref(&pkt.pkt);1614 av_packet_unref(&pkt.pkt);
1747 av_freep(&pkt.bs);1615 av_freep(&pkt.bs);
1748#if QSV_VERSION_ATLEAST(1, 26)
1749 if (avctx->codec_id == AV_CODEC_ID_H264) {1616 if (avctx->codec_id == AV_CODEC_ID_H264) {
1750 av_freep(&enc_info);1617 av_freep(&enc_info);
1751 av_freep(&enc_buf);1618 av_freep(&enc_buf);
1752 }1619 }
1753#endif
1754 }1620 }
1755 1621
1756 return ret;1622 return ret;
@@ -1771,10 +1637,8 @@ int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q, · 14 unmodified lines
1771 if ((av_fifo_can_read(q->async_fifo) >= q->async_depth) ||1637 if ((av_fifo_can_read(q->async_fifo) >= q->async_depth) ||
1772 (!frame && av_fifo_can_read(q->async_fifo))) {1638 (!frame && av_fifo_can_read(q->async_fifo))) {
1773 QSVPacket qpkt;1639 QSVPacket qpkt;
1774#if QSV_VERSION_ATLEAST(1, 26)
1775 mfxExtAVCEncodedFrameInfo *enc_info;1640 mfxExtAVCEncodedFrameInfo *enc_info;
1776 mfxExtBuffer **enc_buf;1641 mfxExtBuffer **enc_buf;
1777#endif
1778 enum AVPictureType pict_type;1642 enum AVPictureType pict_type;
1779 1643
1780 av_fifo_read(q->async_fifo, &qpkt, 1);1644 av_fifo_read(q->async_fifo, &qpkt, 1);
@@ -1804,7 +1668,6 @@ int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q, · 23 unmodified lines
1804 return AVERROR_INVALIDDATA;1668 return AVERROR_INVALIDDATA;
1805 }1669 }
1806 1670
1807#if QSV_VERSION_ATLEAST(1, 26)
1808 if (avctx->codec_id == AV_CODEC_ID_H264) {1671 if (avctx->codec_id == AV_CODEC_ID_H264) {
1809 enc_buf = qpkt.bs->ExtParam;1672 enc_buf = qpkt.bs->ExtParam;
1810 enc_info = (mfxExtAVCEncodedFrameInfo *)(*enc_buf);1673 enc_info = (mfxExtAVCEncodedFrameInfo *)(*enc_buf);
@@ -1813,7 +1676,6 @@ int ff_qsv_encode(AVCodecContext *avctx, QSVEncContext *q, · 2 unmodified lines
1813 av_freep(&enc_info);1676 av_freep(&enc_info);
1814 av_freep(&enc_buf);1677 av_freep(&enc_buf);
1815 }1678 }
1816#endif
1817 av_freep(&qpkt.bs);1679 av_freep(&qpkt.bs);
1818 av_freep(&qpkt.sync);1680 av_freep(&qpkt.sync);
1819 1681
@@ -1850,14 +1712,12 @@ int ff_qsv_enc_close(AVCodecContext *avctx, QSVEncContext *q) · 30 unmodified lines
1850 if (q->async_fifo) {1712 if (q->async_fifo) {
1851 QSVPacket pkt;1713 QSVPacket pkt;
1852 while (av_fifo_read(q->async_fifo, &pkt, 1) >= 0) {1714 while (av_fifo_read(q->async_fifo, &pkt, 1) >= 0) {
1853#if QSV_VERSION_ATLEAST(1, 26)
1854 if (avctx->codec_id == AV_CODEC_ID_H264) {1715 if (avctx->codec_id == AV_CODEC_ID_H264) {
1855 mfxExtBuffer **enc_buf = pkt.bs->ExtParam;1716 mfxExtBuffer **enc_buf = pkt.bs->ExtParam;
1856 mfxExtAVCEncodedFrameInfo *enc_info = (mfxExtAVCEncodedFrameInfo *)(*enc_buf);1717 mfxExtAVCEncodedFrameInfo *enc_info = (mfxExtAVCEncodedFrameInfo *)(*enc_buf);
1857 av_freep(&enc_info);1718 av_freep(&enc_info);
1858 av_freep(&enc_buf);1719 av_freep(&enc_buf);
1859 }1720 }
1860#endif
1861 av_freep(&pkt.sync);1721 av_freep(&pkt.sync);
1862 av_freep(&pkt.bs);1722 av_freep(&pkt.bs);
1863 av_packet_unref(&pkt.pkt);1723 av_packet_unref(&pkt.pkt);
libavcodec/qsvenc.h+9−42
@@ -35,46 +35,16 @@ · 34 unmodified lines
35#include "hwconfig.h"35#include "hwconfig.h"
36#include "qsv_internal.h"36#include "qsv_internal.h"
37 37
38#define QSV_HAVE_CO2 QSV_VERSION_ATLEAST(1, 6)
39#define QSV_HAVE_CO3 QSV_VERSION_ATLEAST(1, 11)
40#define QSV_HAVE_CO_VPS QSV_VERSION_ATLEAST(1, 17)
41
42#define QSV_HAVE_EXT_HEVC_TILES QSV_VERSION_ATLEAST(1, 13)
43#define QSV_HAVE_EXT_VP9_PARAM QSV_VERSION_ATLEAST(1, 26)
44#define QSV_HAVE_EXT_VP9_TILES QSV_VERSION_ATLEAST(1, 29)38#define QSV_HAVE_EXT_VP9_TILES QSV_VERSION_ATLEAST(1, 29)
45 39
46#define QSV_HAVE_TRELLIS QSV_VERSION_ATLEAST(1, 8)
47#define QSV_HAVE_MAX_SLICE_SIZE QSV_VERSION_ATLEAST(1, 9)
48#define QSV_HAVE_DISABLEDEBLOCKIDC QSV_VERSION_ATLEAST(1, 9)
49#define QSV_HAVE_BREF_TYPE QSV_VERSION_ATLEAST(1, 8)
50
51#define QSV_HAVE_LA QSV_VERSION_ATLEAST(1, 7)
52#define QSV_HAVE_LA_DS QSV_VERSION_ATLEAST(1, 8)
53#define QSV_HAVE_LA_HRD QSV_VERSION_ATLEAST(1, 11)
54#define QSV_HAVE_VDENC QSV_VERSION_ATLEAST(1, 15)
55#define QSV_HAVE_PREF QSV_VERSION_ATLEAST(1, 16)
56
57#define QSV_HAVE_GPB QSV_VERSION_ATLEAST(1, 18)
58
59#if defined(_WIN32) || defined(__CYGWIN__)40#if defined(_WIN32) || defined(__CYGWIN__)
60#define QSV_HAVE_AVBR QSV_VERSION_ATLEAST(1, 3)41#define QSV_HAVE_AVBR 1
61#define QSV_HAVE_ICQ QSV_VERSION_ATLEAST(1, 8)42#define QSV_HAVE_VCM 1
62#define QSV_HAVE_VCM QSV_VERSION_ATLEAST(1, 8)
63#define QSV_HAVE_QVBR QSV_VERSION_ATLEAST(1, 11)
64#define QSV_HAVE_MF 043#define QSV_HAVE_MF 0
65#else44#else
66#define QSV_HAVE_AVBR 045#define QSV_HAVE_AVBR 0
67#define QSV_HAVE_ICQ QSV_VERSION_ATLEAST(1, 28)
68#define QSV_HAVE_VCM 046#define QSV_HAVE_VCM 0
69#define QSV_HAVE_QVBR QSV_VERSION_ATLEAST(1, 28)47#define QSV_HAVE_MF 1
70#define QSV_HAVE_MF QSV_VERSION_ATLEAST(1, 25)
71#endif
72
73#if !QSV_HAVE_LA_DS
74#define MFX_LOOKAHEAD_DS_UNKNOWN 0
75#define MFX_LOOKAHEAD_DS_OFF 0
76#define MFX_LOOKAHEAD_DS_2x 0
77#define MFX_LOOKAHEAD_DS_4x 0
78#endif48#endif
79 49
80#define QSV_COMMON_OPTS \50#define QSV_COMMON_OPTS \
@@ -150,22 +120,14 @@ typedef struct QSVEncContext { · 69 unmodified lines
150 mfxFrameAllocRequest req;120 mfxFrameAllocRequest req;
151 121
152 mfxExtCodingOption extco;122 mfxExtCodingOption extco;
153#if QSV_HAVE_CO2
154 mfxExtCodingOption2 extco2;123 mfxExtCodingOption2 extco2;
155#endif
156#if QSV_HAVE_CO3
157 mfxExtCodingOption3 extco3;124 mfxExtCodingOption3 extco3;
158#endif
159#if QSV_HAVE_MF125#if QSV_HAVE_MF
160 mfxExtMultiFrameParam extmfp;126 mfxExtMultiFrameParam extmfp;
161 mfxExtMultiFrameControl extmfc;127 mfxExtMultiFrameControl extmfc;
162#endif128#endif
163#if QSV_HAVE_EXT_HEVC_TILES
164 mfxExtHEVCTiles exthevctiles;129 mfxExtHEVCTiles exthevctiles;
165#endif
166#if QSV_HAVE_EXT_VP9_PARAM
167 mfxExtVP9Param extvp9param;130 mfxExtVP9Param extvp9param;
168#endif
169 131
170 mfxExtOpaqueSurfaceAlloc opaque_alloc;132 mfxExtOpaqueSurfaceAlloc opaque_alloc;
171 mfxFrameSurface1 **opaque_surfaces;133 mfxFrameSurface1 **opaque_surfaces;
@@ -173,7 +135,7 @@ typedef struct QSVEncContext { · 1 unmodified line
173 135
174 mfxExtVideoSignalInfo extvsi;136 mfxExtVideoSignalInfo extvsi;
175 137
176 mfxExtBuffer *extparam_internal[3 + QSV_HAVE_CO2 + QSV_HAVE_CO3 + (QSV_HAVE_MF * 2)];138 mfxExtBuffer *extparam_internal[5 + (QSV_HAVE_MF * 2)];
177 int nb_extparam_internal;139 int nb_extparam_internal;
178 140
179 mfxExtBuffer **extparam;141 mfxExtBuffer **extparam;
@@ -242,6 +204,11 @@ typedef struct QSVEncContext { · 62 unmodified lines
242 SetEncodeCtrlCB *set_encode_ctrl_cb;204 SetEncodeCtrlCB *set_encode_ctrl_cb;
243 int forced_idr;205 int forced_idr;
244 int low_delay_brc;206 int low_delay_brc;
207
208 int co2_idx;
209 int co3_idx;
210 int exthevctiles_idx;
211 int vp9_idx;
245} QSVEncContext;212} QSVEncContext;
246 213
247int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q);214int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q);
libavcodec/qsvenc_h264.c+0−6
@@ -124,11 +124,8 @@ static const AVOption options[] = { · 123 unmodified lines
124 { "single_sei_nal_unit", "Put all the SEI messages into one NALU", OFFSET(qsv.single_sei_nal_unit), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },124 { "single_sei_nal_unit", "Put all the SEI messages into one NALU", OFFSET(qsv.single_sei_nal_unit), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
125 { "max_dec_frame_buffering", "Maximum number of frames buffered in the DPB", OFFSET(qsv.max_dec_frame_buffering), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, UINT16_MAX, VE },125 { "max_dec_frame_buffering", "Maximum number of frames buffered in the DPB", OFFSET(qsv.max_dec_frame_buffering), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, UINT16_MAX, VE },
126 126
127#if QSV_HAVE_LA
128 { "look_ahead", "Use VBR algorithm with look ahead", OFFSET(qsv.look_ahead), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },127 { "look_ahead", "Use VBR algorithm with look ahead", OFFSET(qsv.look_ahead), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
129 { "look_ahead_depth", "Depth of look ahead in number frames", OFFSET(qsv.look_ahead_depth), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 100, VE },128 { "look_ahead_depth", "Depth of look ahead in number frames", OFFSET(qsv.look_ahead_depth), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 100, VE },
130#endif
131#if QSV_HAVE_LA_DS
132 { "look_ahead_downsampling", "Downscaling factor for the frames saved for the lookahead analysis", OFFSET(qsv.look_ahead_downsampling),129 { "look_ahead_downsampling", "Downscaling factor for the frames saved for the lookahead analysis", OFFSET(qsv.look_ahead_downsampling),
133 AV_OPT_TYPE_INT, { .i64 = MFX_LOOKAHEAD_DS_UNKNOWN }, MFX_LOOKAHEAD_DS_UNKNOWN, MFX_LOOKAHEAD_DS_4x, VE, "look_ahead_downsampling" },130 AV_OPT_TYPE_INT, { .i64 = MFX_LOOKAHEAD_DS_UNKNOWN }, MFX_LOOKAHEAD_DS_UNKNOWN, MFX_LOOKAHEAD_DS_4x, VE, "look_ahead_downsampling" },
134 { "unknown" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_LOOKAHEAD_DS_UNKNOWN }, INT_MIN, INT_MAX, VE, "look_ahead_downsampling" },131 { "unknown" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_LOOKAHEAD_DS_UNKNOWN }, INT_MIN, INT_MAX, VE, "look_ahead_downsampling" },
@@ -136,7 +133,6 @@ static const AVOption options[] = { · 1 unmodified line
136 { "off" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_LOOKAHEAD_DS_OFF }, INT_MIN, INT_MAX, VE, "look_ahead_downsampling" },133 { "off" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_LOOKAHEAD_DS_OFF }, INT_MIN, INT_MAX, VE, "look_ahead_downsampling" },
137 { "2x" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_LOOKAHEAD_DS_2x }, INT_MIN, INT_MAX, VE, "look_ahead_downsampling" },134 { "2x" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_LOOKAHEAD_DS_2x }, INT_MIN, INT_MAX, VE, "look_ahead_downsampling" },
138 { "4x" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_LOOKAHEAD_DS_4x }, INT_MIN, INT_MAX, VE, "look_ahead_downsampling" },135 { "4x" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_LOOKAHEAD_DS_4x }, INT_MIN, INT_MAX, VE, "look_ahead_downsampling" },
139#endif
140 136
141 { "int_ref_type", "Intra refresh type. B frames should be set to 0.", OFFSET(qsv.int_ref_type), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, UINT16_MAX, VE, "int_ref_type" },137 { "int_ref_type", "Intra refresh type. B frames should be set to 0.", OFFSET(qsv.int_ref_type), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, UINT16_MAX, VE, "int_ref_type" },
142 { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, .flags = VE, "int_ref_type" },138 { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, .flags = VE, "int_ref_type" },
@@ -145,9 +141,7 @@ static const AVOption options[] = { · 2 unmodified lines
145 { "int_ref_cycle_size", "Number of frames in the intra refresh cycle", OFFSET(qsv.int_ref_cycle_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, UINT16_MAX, VE },141 { "int_ref_cycle_size", "Number of frames in the intra refresh cycle", OFFSET(qsv.int_ref_cycle_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, UINT16_MAX, VE },
146 { "int_ref_qp_delta", "QP difference for the refresh MBs", OFFSET(qsv.int_ref_qp_delta), AV_OPT_TYPE_INT, { .i64 = INT16_MIN }, INT16_MIN, INT16_MAX, VE },142 { "int_ref_qp_delta", "QP difference for the refresh MBs", OFFSET(qsv.int_ref_qp_delta), AV_OPT_TYPE_INT, { .i64 = INT16_MIN }, INT16_MIN, INT16_MAX, VE },
147 { "recovery_point_sei", "Insert recovery point SEI messages", OFFSET(qsv.recovery_point_sei), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },143 { "recovery_point_sei", "Insert recovery point SEI messages", OFFSET(qsv.recovery_point_sei), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
148#if QSV_VERSION_ATLEAST(1, 16)
149 { "int_ref_cycle_dist", "Distance between the beginnings of the intra-refresh cycles in frames", OFFSET(qsv.int_ref_cycle_dist), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT16_MAX, VE },144 { "int_ref_cycle_dist", "Distance between the beginnings of the intra-refresh cycles in frames", OFFSET(qsv.int_ref_cycle_dist), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT16_MAX, VE },
150#endif
151 { "profile", NULL, OFFSET(qsv.profile), AV_OPT_TYPE_INT, { .i64 = MFX_PROFILE_UNKNOWN }, 0, INT_MAX, VE, "profile" },145 { "profile", NULL, OFFSET(qsv.profile), AV_OPT_TYPE_INT, { .i64 = MFX_PROFILE_UNKNOWN }, 0, INT_MAX, VE, "profile" },
152 { "unknown" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_UNKNOWN }, INT_MIN, INT_MAX, VE, "profile" },146 { "unknown" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_UNKNOWN }, INT_MIN, INT_MAX, VE, "profile" },
153 { "baseline", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_AVC_BASELINE }, INT_MIN, INT_MAX, VE, "profile" },147 { "baseline", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_AVC_BASELINE }, INT_MIN, INT_MAX, VE, "profile" },
libavcodec/qsvenc_hevc.c+0−10
@@ -244,9 +244,7 @@ static const AVOption options[] = { · 243 unmodified lines
244 { "load_plugins", "A :-separate list of hexadecimal plugin UIDs to load in an internal session",244 { "load_plugins", "A :-separate list of hexadecimal plugin UIDs to load in an internal session",
245 OFFSET(qsv.load_plugins), AV_OPT_TYPE_STRING, { .str = "" }, 0, 0, VE },245 OFFSET(qsv.load_plugins), AV_OPT_TYPE_STRING, { .str = "" }, 0, 0, VE },
246 246
247#if QSV_HAVE_LA
248 { "look_ahead_depth", "Depth of look ahead in number frames, available when extbrc option is enabled", OFFSET(qsv.look_ahead_depth), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 100, VE },247 { "look_ahead_depth", "Depth of look ahead in number frames, available when extbrc option is enabled", OFFSET(qsv.look_ahead_depth), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 100, VE },
249#endif
250 { "profile", NULL, OFFSET(qsv.profile), AV_OPT_TYPE_INT, { .i64 = MFX_PROFILE_UNKNOWN }, 0, INT_MAX, VE, "profile" },248 { "profile", NULL, OFFSET(qsv.profile), AV_OPT_TYPE_INT, { .i64 = MFX_PROFILE_UNKNOWN }, 0, INT_MAX, VE, "profile" },
251 { "unknown", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_UNKNOWN }, INT_MIN, INT_MAX, VE, "profile" },249 { "unknown", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_UNKNOWN }, INT_MIN, INT_MAX, VE, "profile" },
252 { "main", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_HEVC_MAIN }, INT_MIN, INT_MAX, VE, "profile" },250 { "main", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MFX_PROFILE_HEVC_MAIN }, INT_MIN, INT_MAX, VE, "profile" },
@@ -264,18 +262,14 @@ static const AVOption options[] = { · 11 unmodified lines
264 { "recovery_point_sei", "Insert recovery point SEI messages", OFFSET(qsv.recovery_point_sei), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },262 { "recovery_point_sei", "Insert recovery point SEI messages", OFFSET(qsv.recovery_point_sei), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },
265 { "aud", "Insert the Access Unit Delimiter NAL", OFFSET(qsv.aud), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE},263 { "aud", "Insert the Access Unit Delimiter NAL", OFFSET(qsv.aud), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE},
266 { "pic_timing_sei", "Insert picture timing SEI with pic_struct_syntax element", OFFSET(qsv.pic_timing_sei), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE },264 { "pic_timing_sei", "Insert picture timing SEI with pic_struct_syntax element", OFFSET(qsv.pic_timing_sei), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, VE },
267#if QSV_VERSION_ATLEAST(1, 26)
268 { "transform_skip", "Turn this option ON to enable transformskip", OFFSET(qsv.transform_skip), AV_OPT_TYPE_INT, { .i64 = -1}, -1, 1, VE},265 { "transform_skip", "Turn this option ON to enable transformskip", OFFSET(qsv.transform_skip), AV_OPT_TYPE_INT, { .i64 = -1}, -1, 1, VE},
269#endif
270 { "int_ref_type", "Intra refresh type. B frames should be set to 0", OFFSET(qsv.int_ref_type), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, UINT16_MAX, VE, "int_ref_type" },266 { "int_ref_type", "Intra refresh type. B frames should be set to 0", OFFSET(qsv.int_ref_type), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, UINT16_MAX, VE, "int_ref_type" },
271 { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, .flags = VE, "int_ref_type" },267 { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, .flags = VE, "int_ref_type" },
272 { "vertical", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, .flags = VE, "int_ref_type" },268 { "vertical", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, .flags = VE, "int_ref_type" },
273 { "horizontal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, .flags = VE, "int_ref_type" },269 { "horizontal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, .flags = VE, "int_ref_type" },
274 { "int_ref_cycle_size", "Number of frames in the intra refresh cycle", OFFSET(qsv.int_ref_cycle_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, UINT16_MAX, VE },270 { "int_ref_cycle_size", "Number of frames in the intra refresh cycle", OFFSET(qsv.int_ref_cycle_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, UINT16_MAX, VE },
275 { "int_ref_qp_delta", "QP difference for the refresh MBs", OFFSET(qsv.int_ref_qp_delta), AV_OPT_TYPE_INT, { .i64 = INT16_MIN }, INT16_MIN, INT16_MAX, VE },271 { "int_ref_qp_delta", "QP difference for the refresh MBs", OFFSET(qsv.int_ref_qp_delta), AV_OPT_TYPE_INT, { .i64 = INT16_MIN }, INT16_MIN, INT16_MAX, VE },
276#if QSV_VERSION_ATLEAST(1, 16)
277 { "int_ref_cycle_dist", "Distance between the beginnings of the intra-refresh cycles in frames", OFFSET(qsv.int_ref_cycle_dist), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT16_MAX, VE },272 { "int_ref_cycle_dist", "Distance between the beginnings of the intra-refresh cycles in frames", OFFSET(qsv.int_ref_cycle_dist), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT16_MAX, VE },
278#endif
279 273
280 { NULL },274 { NULL },
281};275};
@@ -315,12 +309,8 @@ const FFCodec ff_hevc_qsv_encoder = { · 33 unmodified lines
315 AV_PIX_FMT_YUYV422,309 AV_PIX_FMT_YUYV422,
316 AV_PIX_FMT_Y210,310 AV_PIX_FMT_Y210,
317 AV_PIX_FMT_QSV,311 AV_PIX_FMT_QSV,
318#if QSV_VERSION_ATLEAST(1, 17)
319 AV_PIX_FMT_BGRA,312 AV_PIX_FMT_BGRA,
320#endif
321#if QSV_VERSION_ATLEAST(1, 9)
322 AV_PIX_FMT_X2RGB10,313 AV_PIX_FMT_X2RGB10,
323#endif
324 AV_PIX_FMT_NONE },314 AV_PIX_FMT_NONE },
325 .p.priv_class = &class,315 .p.priv_class = &class,
326 .defaults = qsv_enc_defaults,316 .defaults = qsv_enc_defaults,
libavfilter/vf_scale_qsv.c+1−12
@@ -69,7 +69,6 @@ enum var_name { · 68 unmodified lines
69 VARS_NB69 VARS_NB
70};70};
71 71
72#define QSV_HAVE_SCALING_CONFIG QSV_VERSION_ATLEAST(1, 19)
73#define MFX_IMPL_VIA_MASK(impl) (0x0f00 & (impl))72#define MFX_IMPL_VIA_MASK(impl) (0x0f00 & (impl))
74 73
75typedef struct QSVScaleContext {74typedef struct QSVScaleContext {
@@ -92,12 +91,10 @@ typedef struct QSVScaleContext { · 16 unmodified lines
92 91
93 mfxExtOpaqueSurfaceAlloc opaque_alloc;92 mfxExtOpaqueSurfaceAlloc opaque_alloc;
94 93
95#if QSV_HAVE_SCALING_CONFIG
96 mfxExtVPPScaling scale_conf;94 mfxExtVPPScaling scale_conf;
97#endif
98 int mode;95 int mode;
99 96
100 mfxExtBuffer *ext_buffers[1 + QSV_HAVE_SCALING_CONFIG];97 mfxExtBuffer *ext_buffers[2];
101 int num_ext_buf;98 int num_ext_buf;
102 99
103 int shift_width, shift_height;100 int shift_width, shift_height;
@@ -397,14 +394,12 @@ static int init_out_session(AVFilterContext *ctx) · 293 unmodified lines
397 par.IOPattern = MFX_IOPATTERN_IN_VIDEO_MEMORY | MFX_IOPATTERN_OUT_VIDEO_MEMORY;394 par.IOPattern = MFX_IOPATTERN_IN_VIDEO_MEMORY | MFX_IOPATTERN_OUT_VIDEO_MEMORY;
398 }395 }
399 396
400#if QSV_HAVE_SCALING_CONFIG
401 memset(&s->scale_conf, 0, sizeof(mfxExtVPPScaling));397 memset(&s->scale_conf, 0, sizeof(mfxExtVPPScaling));
402 s->scale_conf.Header.BufferId = MFX_EXTBUFF_VPP_SCALING;398 s->scale_conf.Header.BufferId = MFX_EXTBUFF_VPP_SCALING;
403 s->scale_conf.Header.BufferSz = sizeof(mfxExtVPPScaling);399 s->scale_conf.Header.BufferSz = sizeof(mfxExtVPPScaling);
404 s->scale_conf.ScalingMode = s->mode;400 s->scale_conf.ScalingMode = s->mode;
405 s->ext_buffers[s->num_ext_buf++] = (mfxExtBuffer*)&s->scale_conf;401 s->ext_buffers[s->num_ext_buf++] = (mfxExtBuffer*)&s->scale_conf;
406 av_log(ctx, AV_LOG_VERBOSE, "Scaling mode: %d\n", s->mode);402 av_log(ctx, AV_LOG_VERBOSE, "Scaling mode: %d\n", s->mode);
407#endif
408 403
409 par.ExtParam = s->ext_buffers;404 par.ExtParam = s->ext_buffers;
410 par.NumExtParam = s->num_ext_buf;405 par.NumExtParam = s->num_ext_buf;
@@ -620,15 +615,9 @@ static const AVOption options[] = { · 209 unmodified lines
620 { "h", "Output video height", OFFSET(h_expr), AV_OPT_TYPE_STRING, { .str = "ih" }, .flags = FLAGS },615 { "h", "Output video height", OFFSET(h_expr), AV_OPT_TYPE_STRING, { .str = "ih" }, .flags = FLAGS },
621 { "format", "Output pixel format", OFFSET(format_str), AV_OPT_TYPE_STRING, { .str = "same" }, .flags = FLAGS },616 { "format", "Output pixel format", OFFSET(format_str), AV_OPT_TYPE_STRING, { .str = "same" }, .flags = FLAGS },
622 617
623#if QSV_HAVE_SCALING_CONFIG
624 { "mode", "set scaling mode", OFFSET(mode), AV_OPT_TYPE_INT, { .i64 = MFX_SCALING_MODE_DEFAULT}, MFX_SCALING_MODE_DEFAULT, MFX_SCALING_MODE_QUALITY, FLAGS, "mode"},618 { "mode", "set scaling mode", OFFSET(mode), AV_OPT_TYPE_INT, { .i64 = MFX_SCALING_MODE_DEFAULT}, MFX_SCALING_MODE_DEFAULT, MFX_SCALING_MODE_QUALITY, FLAGS, "mode"},
625 { "low_power", "low power mode", 0, AV_OPT_TYPE_CONST, { .i64 = MFX_SCALING_MODE_LOWPOWER}, INT_MIN, INT_MAX, FLAGS, "mode"},619 { "low_power", "low power mode", 0, AV_OPT_TYPE_CONST, { .i64 = MFX_SCALING_MODE_LOWPOWER}, INT_MIN, INT_MAX, FLAGS, "mode"},
626 { "hq", "high quality mode", 0, AV_OPT_TYPE_CONST, { .i64 = MFX_SCALING_MODE_QUALITY}, INT_MIN, INT_MAX, FLAGS, "mode"},620 { "hq", "high quality mode", 0, AV_OPT_TYPE_CONST, { .i64 = MFX_SCALING_MODE_QUALITY}, INT_MIN, INT_MAX, FLAGS, "mode"},
627#else
628 { "mode", "(not supported)", OFFSET(mode), AV_OPT_TYPE_INT, { .i64 = 0}, 0, INT_MAX, FLAGS, "mode"},
629 { "low_power", "", 0, AV_OPT_TYPE_CONST, { .i64 = 1}, 0, 0, FLAGS, "mode"},
630 { "hq", "", 0, AV_OPT_TYPE_CONST, { .i64 = 2}, 0, 0, FLAGS, "mode"},
631#endif
632 621
633 { NULL },622 { NULL },
634};623};
libavfilter/vf_vpp_qsv.c+67−76
@@ -43,9 +43,6 @@ · 42 unmodified lines
43 43
44/* number of video enhancement filters */44/* number of video enhancement filters */
45#define ENH_FILTERS_COUNT (8)45#define ENH_FILTERS_COUNT (8)
46#define QSV_HAVE_ROTATION QSV_VERSION_ATLEAST(1, 17)
47#define QSV_HAVE_MIRRORING QSV_VERSION_ATLEAST(1, 19)
48#define QSV_HAVE_SCALING_CONFIG QSV_VERSION_ATLEAST(1, 19)
49 46
50typedef struct VPPContext{47typedef struct VPPContext{
51 const AVClass *class;48 const AVClass *class;
@@ -60,9 +57,7 @@ typedef struct VPPContext{ · 8 unmodified lines
60 mfxExtVPPProcAmp procamp_conf;57 mfxExtVPPProcAmp procamp_conf;
61 mfxExtVPPRotation rotation_conf;58 mfxExtVPPRotation rotation_conf;
62 mfxExtVPPMirroring mirroring_conf;59 mfxExtVPPMirroring mirroring_conf;
63#ifdef QSV_HAVE_SCALING_CONFIG
64 mfxExtVPPScaling scale_conf;60 mfxExtVPPScaling scale_conf;
65#endif
66 61
67 int out_width;62 int out_width;
68 int out_height;63 int out_height;
@@ -138,9 +133,7 @@ static const AVOption options[] = { · 69 unmodified lines
138 { "height", "Output video height", OFFSET(oh), AV_OPT_TYPE_STRING, { .str="w*ch/cw" }, 0, 255, .flags = FLAGS },133 { "height", "Output video height", OFFSET(oh), AV_OPT_TYPE_STRING, { .str="w*ch/cw" }, 0, 255, .flags = FLAGS },
139 { "format", "Output pixel format", OFFSET(output_format_str), AV_OPT_TYPE_STRING, { .str = "same" }, .flags = FLAGS },134 { "format", "Output pixel format", OFFSET(output_format_str), AV_OPT_TYPE_STRING, { .str = "same" }, .flags = FLAGS },
140 { "async_depth", "Internal parallelization depth, the higher the value the higher the latency.", OFFSET(async_depth), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, .flags = FLAGS },135 { "async_depth", "Internal parallelization depth, the higher the value the higher the latency.", OFFSET(async_depth), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, .flags = FLAGS },
141#ifdef QSV_HAVE_SCALING_CONFIG
142 { "scale_mode", "scale mode: 0=auto, 1=low power, 2=high quality", OFFSET(scale_mode), AV_OPT_TYPE_INT, { .i64 = MFX_SCALING_MODE_DEFAULT }, MFX_SCALING_MODE_DEFAULT, MFX_SCALING_MODE_QUALITY, .flags = FLAGS, "scale mode" },136 { "scale_mode", "scale mode: 0=auto, 1=low power, 2=high quality", OFFSET(scale_mode), AV_OPT_TYPE_INT, { .i64 = MFX_SCALING_MODE_DEFAULT }, MFX_SCALING_MODE_DEFAULT, MFX_SCALING_MODE_QUALITY, .flags = FLAGS, "scale mode" },
143#endif
144 { NULL }137 { NULL }
145};138};
146 139
@@ -422,84 +415,83 @@ static int config_output(AVFilterLink *outlink) · 275 unmodified lines
422 }415 }
423 416
424 if (vpp->transpose >= 0) {417 if (vpp->transpose >= 0) {
425#ifdef QSV_HAVE_ROTATION418 if (QSV_RUNTIME_VERSION_ATLEAST(mfx_version, 1, 17)) {
426 switch (vpp->transpose) {419 switch (vpp->transpose) {
427 case TRANSPOSE_CCLOCK_FLIP:420 case TRANSPOSE_CCLOCK_FLIP:
428 vpp->rotate = MFX_ANGLE_270;421 vpp->rotate = MFX_ANGLE_270;
429 vpp->hflip = MFX_MIRRORING_HORIZONTAL;422 vpp->hflip = MFX_MIRRORING_HORIZONTAL;
430 break;423 break;
431 case TRANSPOSE_CLOCK:424 case TRANSPOSE_CLOCK:
432 vpp->rotate = MFX_ANGLE_90;425 vpp->rotate = MFX_ANGLE_90;
433 vpp->hflip = MFX_MIRRORING_DISABLED;426 vpp->hflip = MFX_MIRRORING_DISABLED;
434 break;427 break;
435 case TRANSPOSE_CCLOCK:428 case TRANSPOSE_CCLOCK:
436 vpp->rotate = MFX_ANGLE_270;429 vpp->rotate = MFX_ANGLE_270;
437 vpp->hflip = MFX_MIRRORING_DISABLED;430 vpp->hflip = MFX_MIRRORING_DISABLED;
438 break;431 break;
439 case TRANSPOSE_CLOCK_FLIP:432 case TRANSPOSE_CLOCK_FLIP:
440 vpp->rotate = MFX_ANGLE_90;433 vpp->rotate = MFX_ANGLE_90;
441 vpp->hflip = MFX_MIRRORING_HORIZONTAL;434 vpp->hflip = MFX_MIRRORING_HORIZONTAL;
442 break;435 break;
443 case TRANSPOSE_REVERSAL:436 case TRANSPOSE_REVERSAL:
444 vpp->rotate = MFX_ANGLE_180;437 vpp->rotate = MFX_ANGLE_180;
445 vpp->hflip = MFX_MIRRORING_DISABLED;438 vpp->hflip = MFX_MIRRORING_DISABLED;
446 break;439 break;
447 case TRANSPOSE_HFLIP:440 case TRANSPOSE_HFLIP:
448 vpp->rotate = MFX_ANGLE_0;441 vpp->rotate = MFX_ANGLE_0;
449 vpp->hflip = MFX_MIRRORING_HORIZONTAL;442 vpp->hflip = MFX_MIRRORING_HORIZONTAL;
450 break;443 break;
451 case TRANSPOSE_VFLIP:444 case TRANSPOSE_VFLIP:
452 vpp->rotate = MFX_ANGLE_180;445 vpp->rotate = MFX_ANGLE_180;
453 vpp->hflip = MFX_MIRRORING_HORIZONTAL;446 vpp->hflip = MFX_MIRRORING_HORIZONTAL;
454 break;447 break;
455 default:448 default:
456 av_log(ctx, AV_LOG_ERROR, "Failed to set transpose mode to %d.\n", vpp->transpose);449 av_log(ctx, AV_LOG_ERROR, "Failed to set transpose mode to %d.\n", vpp->transpose);
457 return AVERROR(EINVAL);450 return AVERROR(EINVAL);
451 }
452 } else {
453 av_log(ctx, AV_LOG_WARNING, "The QSV VPP transpose option is "
454 "not supported with this MSDK version.\n");
455 vpp->transpose = 0;
458 }456 }
459#else
460 av_log(ctx, AV_LOG_WARNING, "The QSV VPP transpose option is "
461 "not supported with this MSDK version.\n");
462 vpp->transpose = 0;
463#endif
464 }457 }
465 458
466 if (vpp->rotate) {459 if (vpp->rotate) {
467#ifdef QSV_HAVE_ROTATION460 if (QSV_RUNTIME_VERSION_ATLEAST(mfx_version, 1, 17)) {
468 memset(&vpp->rotation_conf, 0, sizeof(mfxExtVPPRotation));461 memset(&vpp->rotation_conf, 0, sizeof(mfxExtVPPRotation));
469 vpp->rotation_conf.Header.BufferId = MFX_EXTBUFF_VPP_ROTATION;462 vpp->rotation_conf.Header.BufferId = MFX_EXTBUFF_VPP_ROTATION;
470 vpp->rotation_conf.Header.BufferSz = sizeof(mfxExtVPPRotation);463 vpp->rotation_conf.Header.BufferSz = sizeof(mfxExtVPPRotation);
471 vpp->rotation_conf.Angle = vpp->rotate;464 vpp->rotation_conf.Angle = vpp->rotate;
472 465
473 if (MFX_ANGLE_90 == vpp->rotate || MFX_ANGLE_270 == vpp->rotate) {466 if (MFX_ANGLE_90 == vpp->rotate || MFX_ANGLE_270 == vpp->rotate) {
474 FFSWAP(int, vpp->out_width, vpp->out_height);467 FFSWAP(int, vpp->out_width, vpp->out_height);
475 FFSWAP(int, outlink->w, outlink->h);468 FFSWAP(int, outlink->w, outlink->h);
476 av_log(ctx, AV_LOG_DEBUG, "Swap width and height for clock/cclock rotation.\n");469 av_log(ctx, AV_LOG_DEBUG, "Swap width and height for clock/cclock rotation.\n");
477 }470 }
478 471
479 param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->rotation_conf;472 param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->rotation_conf;
480#else473 } else {
481 av_log(ctx, AV_LOG_WARNING, "The QSV VPP rotate option is "474 av_log(ctx, AV_LOG_WARNING, "The QSV VPP rotate option is "
482 "not supported with this MSDK version.\n");475 "not supported with this MSDK version.\n");
483 vpp->rotate = 0;476 vpp->rotate = 0;
484#endif477 }
485 }478 }
486 479
487 if (vpp->hflip) {480 if (vpp->hflip) {
488#ifdef QSV_HAVE_MIRRORING481 if (QSV_RUNTIME_VERSION_ATLEAST(mfx_version, 1, 19)) {
489 memset(&vpp->mirroring_conf, 0, sizeof(mfxExtVPPMirroring));482 memset(&vpp->mirroring_conf, 0, sizeof(mfxExtVPPMirroring));
490 vpp->mirroring_conf.Header.BufferId = MFX_EXTBUFF_VPP_MIRRORING;483 vpp->mirroring_conf.Header.BufferId = MFX_EXTBUFF_VPP_MIRRORING;
491 vpp->mirroring_conf.Header.BufferSz = sizeof(mfxExtVPPMirroring);484 vpp->mirroring_conf.Header.BufferSz = sizeof(mfxExtVPPMirroring);
492 vpp->mirroring_conf.Type = vpp->hflip;485 vpp->mirroring_conf.Type = vpp->hflip;
493 486
494 param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->mirroring_conf;487 param.ext_buf[param.num_ext_buf++] = (mfxExtBuffer*)&vpp->mirroring_conf;
495#else488 } else {
496 av_log(ctx, AV_LOG_WARNING, "The QSV VPP hflip option is "489 av_log(ctx, AV_LOG_WARNING, "The QSV VPP hflip option is "
497 "not supported with this MSDK version.\n");490 "not supported with this MSDK version.\n");
498 vpp->hflip = 0;491 vpp->hflip = 0;
499#endif492 }
500 }493 }
501 494
502#ifdef QSV_HAVE_SCALING_CONFIG
503 if (inlink->w != outlink->w || inlink->h != outlink->h) {495 if (inlink->w != outlink->w || inlink->h != outlink->h) {
504 if (QSV_RUNTIME_VERSION_ATLEAST(mfx_version, 1, 19)) {496 if (QSV_RUNTIME_VERSION_ATLEAST(mfx_version, 1, 19)) {
505 memset(&vpp->scale_conf, 0, sizeof(mfxExtVPPScaling));497 memset(&vpp->scale_conf, 0, sizeof(mfxExtVPPScaling));
@@ -512,7 +504,6 @@ static int config_output(AVFilterLink *outlink) · 6 unmodified lines
512 av_log(ctx, AV_LOG_WARNING, "The QSV VPP Scale option is "504 av_log(ctx, AV_LOG_WARNING, "The QSV VPP Scale option is "
513 "not supported with this MSDK version.\n");505 "not supported with this MSDK version.\n");
514 }506 }
515#endif
516 507
517 if (vpp->use_frc || vpp->use_crop || vpp->deinterlace || vpp->denoise ||508 if (vpp->use_frc || vpp->use_crop || vpp->deinterlace || vpp->denoise ||
518 vpp->detail || vpp->procamp || vpp->rotate || vpp->hflip ||509 vpp->detail || vpp->procamp || vpp->rotate || vpp->hflip ||
libavutil/hwcontext_qsv.c+0−2
@@ -106,11 +106,9 @@ static const struct { · 105 unmodified lines
106#if CONFIG_VAAPI106#if CONFIG_VAAPI
107 { AV_PIX_FMT_YUYV422,107 { AV_PIX_FMT_YUYV422,
108 MFX_FOURCC_YUY2 },108 MFX_FOURCC_YUY2 },
109#if QSV_VERSION_ATLEAST(1, 27)
110 { AV_PIX_FMT_Y210,109 { AV_PIX_FMT_Y210,
111 MFX_FOURCC_Y210 },110 MFX_FOURCC_Y210 },
112#endif111#endif
113#endif
114};112};
115 113
116extern int ff_qsv_get_surface_base_handle(mfxFrameSurface1 *surf,114extern int ff_qsv_get_surface_base_handle(mfxFrameSurface1 *surf,

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t