39 #define CHECK_CU(x) FF_CUDA_CHECK_DL(avctx, dl_fn->cuda_dl, x) 41 #define NVENC_CAP 0x30 42 #define IS_CBR(rc) (rc == NV_ENC_PARAMS_RC_CBR || \ 43 rc == NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ || \ 44 rc == NV_ENC_PARAMS_RC_CBR_HQ) 72 #define IS_10BIT(pix_fmt) (pix_fmt == AV_PIX_FMT_P010 || \ 73 pix_fmt == AV_PIX_FMT_P016 || \ 74 pix_fmt == AV_PIX_FMT_YUV444P16) 76 #define IS_YUV444(pix_fmt) (pix_fmt == AV_PIX_FMT_YUV444P || \ 77 pix_fmt == AV_PIX_FMT_YUV444P16) 84 { NV_ENC_SUCCESS, 0,
"success" },
85 { NV_ENC_ERR_NO_ENCODE_DEVICE,
AVERROR(ENOENT),
"no encode device" },
86 { NV_ENC_ERR_UNSUPPORTED_DEVICE,
AVERROR(ENOSYS),
"unsupported device" },
87 { NV_ENC_ERR_INVALID_ENCODERDEVICE,
AVERROR(EINVAL),
"invalid encoder device" },
88 { NV_ENC_ERR_INVALID_DEVICE,
AVERROR(EINVAL),
"invalid device" },
89 { NV_ENC_ERR_DEVICE_NOT_EXIST,
AVERROR(EIO),
"device does not exist" },
90 { NV_ENC_ERR_INVALID_PTR,
AVERROR(EFAULT),
"invalid ptr" },
91 { NV_ENC_ERR_INVALID_EVENT,
AVERROR(EINVAL),
"invalid event" },
92 { NV_ENC_ERR_INVALID_PARAM,
AVERROR(EINVAL),
"invalid param" },
93 { NV_ENC_ERR_INVALID_CALL,
AVERROR(EINVAL),
"invalid call" },
94 { NV_ENC_ERR_OUT_OF_MEMORY,
AVERROR(ENOMEM),
"out of memory" },
95 { NV_ENC_ERR_ENCODER_NOT_INITIALIZED,
AVERROR(EINVAL),
"encoder not initialized" },
96 { NV_ENC_ERR_UNSUPPORTED_PARAM,
AVERROR(ENOSYS),
"unsupported param" },
97 { NV_ENC_ERR_LOCK_BUSY,
AVERROR(EAGAIN),
"lock busy" },
99 { NV_ENC_ERR_INVALID_VERSION,
AVERROR(EINVAL),
"invalid version" },
100 { NV_ENC_ERR_MAP_FAILED,
AVERROR(EIO),
"map failed" },
101 { NV_ENC_ERR_NEED_MORE_INPUT,
AVERROR(EAGAIN),
"need more input" },
102 { NV_ENC_ERR_ENCODER_BUSY,
AVERROR(EAGAIN),
"encoder busy" },
103 { NV_ENC_ERR_EVENT_NOT_REGISTERD,
AVERROR(EBADF),
"event not registered" },
105 { NV_ENC_ERR_INCOMPATIBLE_CLIENT_KEY,
AVERROR(EINVAL),
"incompatible client key" },
106 { NV_ENC_ERR_UNIMPLEMENTED,
AVERROR(ENOSYS),
"unimplemented" },
107 { NV_ENC_ERR_RESOURCE_REGISTER_FAILED,
AVERROR(EIO),
"resource register failed" },
108 { NV_ENC_ERR_RESOURCE_NOT_REGISTERED,
AVERROR(EBADF),
"resource not registered" },
109 { NV_ENC_ERR_RESOURCE_NOT_MAPPED,
AVERROR(EBADF),
"resource not mapped" },
123 *desc =
"unknown error";
128 const char *error_string)
131 const char *details =
"(no details)";
134 #ifdef NVENC_HAVE_GETLASTERRORSTRING 139 details = p_nvenc->nvEncGetLastErrorString(ctx->
nvencoder);
149 #if NVENCAPI_CHECK_VERSION(11, 1) 150 const char *minver =
"(unknown)";
151 #elif NVENCAPI_CHECK_VERSION(11, 0) 152 # if defined(_WIN32) || defined(__CYGWIN__) 153 const char *minver =
"456.71";
155 const char *minver =
"455.28";
157 #elif NVENCAPI_CHECK_VERSION(10, 0) 158 # if defined(_WIN32) || defined(__CYGWIN__) 159 const char *minver =
"450.51";
161 const char *minver =
"445.87";
163 #elif NVENCAPI_CHECK_VERSION(9, 1) 164 # if defined(_WIN32) || defined(__CYGWIN__) 165 const char *minver =
"436.15";
167 const char *minver =
"435.21";
169 #elif NVENCAPI_CHECK_VERSION(9, 0) 170 # if defined(_WIN32) || defined(__CYGWIN__) 171 const char *minver =
"418.81";
173 const char *minver =
"418.30";
175 #elif NVENCAPI_CHECK_VERSION(8, 2) 176 # if defined(_WIN32) || defined(__CYGWIN__) 177 const char *minver =
"397.93";
179 const char *minver =
"396.24";
181 #elif NVENCAPI_CHECK_VERSION(8, 1) 182 # if defined(_WIN32) || defined(__CYGWIN__) 183 const char *minver =
"390.77";
185 const char *minver =
"390.25";
188 # if defined(_WIN32) || defined(__CYGWIN__) 189 const char *minver =
"378.66";
191 const char *minver =
"378.13";
194 av_log(avctx, level,
"The minimum required Nvidia driver for nvenc is %s or newer\n", minver);
202 uint32_t nvenc_max_ver;
205 ret = cuda_load_functions(&dl_fn->
cuda_dl, avctx);
209 ret = nvenc_load_functions(&dl_fn->
nvenc_dl, avctx);
215 err = dl_fn->
nvenc_dl->NvEncodeAPIGetMaxSupportedVersion(&nvenc_max_ver);
216 if (err != NV_ENC_SUCCESS)
221 if ((NVENCAPI_MAJOR_VERSION << 4 | NVENCAPI_MINOR_VERSION) > nvenc_max_ver) {
222 av_log(avctx,
AV_LOG_ERROR,
"Driver does not support the required nvenc API version. " 223 "Required: %d.%d Found: %d.%d\n",
224 NVENCAPI_MAJOR_VERSION, NVENCAPI_MINOR_VERSION,
225 nvenc_max_ver >> 4, nvenc_max_ver & 0xf);
230 dl_fn->
nvenc_funcs.version = NV_ENCODE_API_FUNCTION_LIST_VER;
233 if (err != NV_ENC_SUCCESS)
266 NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS
params = { 0 };
271 params.version = NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS_VER;
272 params.apiVersion = NVENCAPI_VERSION;
275 params.deviceType = NV_ENC_DEVICE_TYPE_DIRECTX;
278 params.deviceType = NV_ENC_DEVICE_TYPE_CUDA;
281 ret = p_nvenc->nvEncOpenEncodeSessionEx(¶ms, &ctx->
nvencoder);
282 if (ret != NV_ENC_SUCCESS) {
297 ret = p_nvenc->nvEncGetEncodeGUIDCount(ctx->
nvencoder, &count);
299 if (ret != NV_ENC_SUCCESS || !count)
306 ret = p_nvenc->nvEncGetEncodeGUIDs(ctx->
nvencoder, guids, count, &count);
307 if (ret != NV_ENC_SUCCESS) {
313 for (i = 0; i <
count; i++) {
330 NV_ENC_CAPS_PARAM
params = { 0 };
333 params.version = NV_ENC_CAPS_PARAM_VER;
334 params.capsToQuery = cap;
338 if (ret == NV_ENC_SUCCESS)
367 if (ret < avctx->
width) {
374 if (ret < avctx->
height) {
381 if (ret < avctx->max_b_frames) {
391 "Interlaced encoding is not supported. Supported level: %d\n",
421 if (ctx->
coder == NV_ENC_H264_ENTROPY_CODING_MODE_CABAC && ret <= 0) {
426 #ifdef NVENC_HAVE_BFRAME_REF_MODE 428 if (ctx->
b_ref_mode == NV_ENC_BFRAME_REF_MODE_EACH && ret != 1 && ret != 3) {
431 }
else if (ctx->
b_ref_mode != NV_ENC_BFRAME_REF_MODE_DISABLED && ret == 0) {
442 #ifdef NVENC_HAVE_MULTIPLE_REF_FRAMES 444 if(avctx->
refs != NV_ENC_NUM_REF_FRAMES_AUTOSELECT && ret <= 0) {
449 if(avctx->
refs != 0) {
464 NV_ENCODE_API_FUNCTION_LIST *p_nvenc = &dl_fn->
nvenc_funcs;
465 char name[128] = { 0};
477 ret =
CHECK_CU(dl_fn->
cuda_dl->cuDeviceGetName(name,
sizeof(name), cu_device));
481 ret =
CHECK_CU(dl_fn->
cuda_dl->cuDeviceComputeCapability(&major, &minor, cu_device));
485 av_log(avctx, loglevel,
"[ GPU #%d - < %s > has Compute SM %d.%d ]\n", idx, name, major, minor);
486 if (((major << 4) | minor) <
NVENC_CAP) {
487 av_log(avctx, loglevel,
"does not support NVENC\n");
510 av_log(avctx, loglevel,
"supports NVENC\n");
521 p_nvenc->nvEncDestroyEncoder(ctx->
nvencoder);
573 cuda_device_hwctx = hwdev_ctx->
hwctx;
576 d3d11_device_hwctx = hwdev_ctx->
hwctx;
584 if (cuda_device_hwctx) {
589 else if (d3d11_device_hwctx) {
601 av_log(avctx,
AV_LOG_FATAL,
"Provided device doesn't support required NVENC features\n");
605 int i, nb_devices = 0;
621 for (i = 0; i < nb_devices; ++
i) {
646 #define PRESET_ALIAS(alias, name, ...) \ 647 [PRESET_ ## alias] = { NV_ENC_PRESET_ ## name ## _GUID, __VA_ARGS__ } 649 #define PRESET(name, ...) PRESET_ALIAS(name, name, __VA_ARGS__) 654 #ifdef NVENC_HAVE_NEW_PRESETS 705 rc->rateControlMode = NV_ENC_PARAMS_RC_CONSTQP;
713 rc->constQP.qpIntra = av_clip(
715 rc->constQP.qpInterB = av_clip(
718 rc->constQP.qpIntra = rc->constQP.qpInterP;
719 rc->constQP.qpInterB = rc->constQP.qpInterP;
721 }
else if (ctx->
cqp >= 0) {
722 rc->constQP.qpInterP = rc->constQP.qpInterB = rc->constQP.qpIntra = ctx->
cqp;
739 if (avctx->
qmin >= 0 && avctx->
qmax >= 0) {
743 rc->minQP.qpInterB = avctx->
qmin;
744 rc->minQP.qpInterP = avctx->
qmin;
745 rc->minQP.qpIntra = avctx->
qmin;
747 rc->maxQP.qpInterB = avctx->
qmax;
748 rc->maxQP.qpInterP = avctx->
qmax;
749 rc->maxQP.qpIntra = avctx->
qmax;
751 qp_inter_p = (avctx->
qmax + 3 * avctx->
qmin) / 4;
752 }
else if (avctx->
qmin >= 0) {
755 rc->minQP.qpInterB = avctx->
qmin;
756 rc->minQP.qpInterP = avctx->
qmin;
757 rc->minQP.qpIntra = avctx->
qmin;
759 qp_inter_p = avctx->
qmin;
764 rc->enableInitialRCQP = 1;
767 rc->initialRCQP.qpInterP = qp_inter_p;
769 rc->initialRCQP.qpInterP = ctx->
init_qp_p;
774 rc->initialRCQP.qpIntra = av_clip(
777 rc->initialRCQP.qpIntra = rc->initialRCQP.qpInterP;
780 rc->initialRCQP.qpIntra = ctx->
init_qp_i;
785 rc->initialRCQP.qpInterB = av_clip(
788 rc->initialRCQP.qpInterB = rc->initialRCQP.qpInterP;
791 rc->initialRCQP.qpInterB = ctx->
init_qp_b;
800 rc->rateControlMode = NV_ENC_PARAMS_RC_CONSTQP;
801 rc->constQP.qpInterB = 0;
802 rc->constQP.qpInterP = 0;
803 rc->constQP.qpIntra = 0;
815 case NV_ENC_PARAMS_RC_CONSTQP:
818 case NV_ENC_PARAMS_RC_VBR_MINQP:
819 if (avctx->
qmin < 0) {
821 "The variable bitrate rate-control requires " 822 "the 'qmin' option set.\n");
827 case NV_ENC_PARAMS_RC_VBR_HQ:
828 case NV_ENC_PARAMS_RC_VBR:
831 case NV_ENC_PARAMS_RC_CBR:
832 case NV_ENC_PARAMS_RC_CBR_HQ:
833 case NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ:
837 rc->rateControlMode = ctx->
rc;
856 "Defined rc_lookahead requires more surfaces, " 857 "increasing used surfaces %d -> %d\n", ctx->
nb_surfaces, nb_surfaces);
864 "Defined b-frame requires more surfaces, " 865 "increasing used surfaces %d -> %d\n", ctx->
nb_surfaces, nb_surfaces);
884 av_log(avctx,
AV_LOG_WARNING,
"Using global_quality with nvenc is deprecated. Use qp instead.\n");
898 #ifdef NVENC_HAVE_MULTIPASS 902 ctx->
encode_config.rcParams.multiPass = NV_ENC_MULTI_PASS_DISABLED;
904 ctx->
encode_config.rcParams.multiPass = NV_ENC_TWO_PASS_FULL_RESOLUTION;
908 ctx->
rc = NV_ENC_PARAMS_RC_CBR;
909 }
else if (ctx->
cqp >= 0) {
910 ctx->
rc = NV_ENC_PARAMS_RC_CONSTQP;
911 }
else if (ctx->
quality >= 0.0f) {
912 ctx->
rc = NV_ENC_PARAMS_RC_VBR;
927 ctx->
rc = NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ;
929 ctx->
rc = NV_ENC_PARAMS_RC_CBR;
931 }
else if (ctx->
cqp >= 0) {
932 ctx->
rc = NV_ENC_PARAMS_RC_CONSTQP;
934 ctx->
rc = NV_ENC_PARAMS_RC_VBR_HQ;
935 }
else if (avctx->
qmin >= 0 && avctx->
qmax >= 0) {
936 ctx->
rc = NV_ENC_PARAMS_RC_VBR_MINQP;
948 #ifdef NVENC_HAVE_LDKFS 955 }
else if (ctx->
rc >= 0) {
958 ctx->
encode_config.rcParams.rateControlMode = NV_ENC_PARAMS_RC_VBR;
985 "Lookahead not enabled. Increase buffer delay (-delay).\n");
992 "Lookahead enabled: depth %d, scenecut %s, B-adapt %s.\n",
994 ctx->
encode_config.rcParams.disableIadapt ?
"disabled" :
"enabled",
995 ctx->
encode_config.rcParams.disableBadapt ?
"disabled" :
"enabled");
1012 int tmp_quality = (
int)(ctx->
quality * 256.0f);
1028 NV_ENC_CONFIG_H264 *h264 = &cc->encodeCodecConfig.h264Config;
1029 NV_ENC_CONFIG_H264_VUI_PARAMETERS *vui = &h264->h264VUIParameters;
1033 vui->transferCharacteristics = avctx->
color_trc;
1037 vui->colourDescriptionPresentFlag =
1040 vui->videoSignalTypePresentFlag =
1041 (vui->colourDescriptionPresentFlag
1042 || vui->videoFormat != 5
1043 || vui->videoFullRangeFlag != 0);
1045 h264->sliceMode = 3;
1046 h264->sliceModeData = 1;
1050 h264->outputAUD = ctx->
aud;
1054 h264->maxNumRefFrames = ctx->
dpb_size;
1057 h264->idrPeriod = cc->gopLength;
1060 if (
IS_CBR(cc->rcParams.rateControlMode)) {
1061 h264->outputBufferingPeriodSEI = 1;
1064 h264->outputPictureTimingSEI = 1;
1066 if (cc->rcParams.rateControlMode == NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ ||
1067 cc->rcParams.rateControlMode == NV_ENC_PARAMS_RC_CBR_HQ ||
1068 cc->rcParams.rateControlMode == NV_ENC_PARAMS_RC_VBR_HQ) {
1069 h264->adaptiveTransformMode = NV_ENC_H264_ADAPTIVE_TRANSFORM_ENABLE;
1070 h264->fmoMode = NV_ENC_H264_FMO_DISABLE;
1074 h264->qpPrimeYZeroTransformBypassFlag = 1;
1078 cc->profileGUID = NV_ENC_H264_PROFILE_BASELINE_GUID;
1082 cc->profileGUID = NV_ENC_H264_PROFILE_MAIN_GUID;
1086 cc->profileGUID = NV_ENC_H264_PROFILE_HIGH_GUID;
1090 cc->profileGUID = NV_ENC_H264_PROFILE_HIGH_444_GUID;
1098 cc->profileGUID = NV_ENC_H264_PROFILE_HIGH_444_GUID;
1104 h264->level = ctx->
level;
1106 if (ctx->
coder >= 0)
1107 h264->entropyCodingMode = ctx->
coder;
1109 #ifdef NVENC_HAVE_BFRAME_REF_MODE 1113 #ifdef NVENC_HAVE_MULTIPLE_REF_FRAMES 1114 h264->numRefL0 = avctx->
refs;
1115 h264->numRefL1 = avctx->
refs;
1125 NV_ENC_CONFIG_HEVC *hevc = &cc->encodeCodecConfig.hevcConfig;
1126 NV_ENC_CONFIG_HEVC_VUI_PARAMETERS *vui = &hevc->hevcVUIParameters;
1130 vui->transferCharacteristics = avctx->
color_trc;
1134 vui->colourDescriptionPresentFlag =
1137 vui->videoSignalTypePresentFlag =
1138 (vui->colourDescriptionPresentFlag
1139 || vui->videoFormat != 5
1140 || vui->videoFullRangeFlag != 0);
1142 hevc->sliceMode = 3;
1143 hevc->sliceModeData = 1;
1147 hevc->outputAUD = ctx->
aud;
1151 hevc->maxNumRefFramesInDPB = ctx->
dpb_size;
1154 hevc->idrPeriod = cc->gopLength;
1157 if (
IS_CBR(cc->rcParams.rateControlMode)) {
1158 hevc->outputBufferingPeriodSEI = 1;
1161 hevc->outputPictureTimingSEI = 1;
1165 cc->profileGUID = NV_ENC_HEVC_PROFILE_MAIN_GUID;
1169 cc->profileGUID = NV_ENC_HEVC_PROFILE_MAIN10_GUID;
1173 cc->profileGUID = NV_ENC_HEVC_PROFILE_FREXT_GUID;
1180 cc->profileGUID = NV_ENC_HEVC_PROFILE_MAIN10_GUID;
1186 cc->profileGUID = NV_ENC_HEVC_PROFILE_FREXT_GUID;
1194 hevc->level = ctx->
level;
1196 hevc->tier = ctx->
tier;
1198 #ifdef NVENC_HAVE_HEVC_BFRAME_REF_MODE 1202 #ifdef NVENC_HAVE_MULTIPLE_REF_FRAMES 1203 hevc->numRefL0 = avctx->
refs;
1204 hevc->numRefL1 = avctx->
refs;
1241 NV_ENCODE_API_FUNCTION_LIST *p_nvenc = &dl_fn->
nvenc_funcs;
1243 NV_ENC_PRESET_CONFIG preset_config = { 0 };
1244 NVENCSTATUS nv_status = NV_ENC_SUCCESS;
1260 av_log(avctx,
AV_LOG_WARNING,
"The selected preset is deprecated. Use p1 to p7 + -tune or fast/medium/slow.\n");
1262 preset_config.version = NV_ENC_PRESET_CONFIG_VER;
1263 preset_config.presetCfg.version = NV_ENC_CONFIG_VER;
1265 #ifdef NVENC_HAVE_NEW_PRESETS 1271 nv_status = p_nvenc->nvEncGetEncodePresetConfigEx(ctx->
nvencoder,
1277 nv_status = p_nvenc->nvEncGetEncodePresetConfig(ctx->
nvencoder,
1282 if (nv_status != NV_ENC_SUCCESS)
1283 return nvenc_print_error(avctx, nv_status,
"Cannot get the preset configuration");
1304 #ifdef NVENC_HAVE_NEW_PRESETS 1327 ctx->
level = NV_ENC_LEVEL_HEVC_51;
1328 ctx->
tier = NV_ENC_TIER_HEVC_HIGH;
1350 ctx->
encode_config.frameFieldMode = NV_ENC_PARAMS_FRAME_FIELD_MODE_FIELD;
1352 ctx->
encode_config.frameFieldMode = NV_ENC_PARAMS_FRAME_FIELD_MODE_FRAME;
1364 if (nv_status != NV_ENC_SUCCESS) {
1369 #ifdef NVENC_HAVE_CUSTREAM_PTR 1372 if (nv_status != NV_ENC_SUCCESS) {
1403 return NV_ENC_BUFFER_FORMAT_YV12_PL;
1405 return NV_ENC_BUFFER_FORMAT_NV12_PL;
1408 return NV_ENC_BUFFER_FORMAT_YUV420_10BIT;
1410 return NV_ENC_BUFFER_FORMAT_YUV444_PL;
1412 return NV_ENC_BUFFER_FORMAT_YUV444_10BIT;
1414 return NV_ENC_BUFFER_FORMAT_ARGB;
1416 return NV_ENC_BUFFER_FORMAT_ABGR;
1418 return NV_ENC_BUFFER_FORMAT_UNDEFINED;
1426 NV_ENCODE_API_FUNCTION_LIST *p_nvenc = &dl_fn->
nvenc_funcs;
1429 NVENCSTATUS nv_status;
1430 NV_ENC_CREATE_BITSTREAM_BUFFER allocOut = { 0 };
1431 allocOut.version = NV_ENC_CREATE_BITSTREAM_BUFFER_VER;
1438 NV_ENC_CREATE_INPUT_BUFFER allocSurf = { 0 };
1441 if (ctx->
surfaces[idx].
format == NV_ENC_BUFFER_FORMAT_UNDEFINED) {
1447 allocSurf.version = NV_ENC_CREATE_INPUT_BUFFER_VER;
1448 allocSurf.width = avctx->
width;
1449 allocSurf.height = avctx->
height;
1452 nv_status = p_nvenc->nvEncCreateInputBuffer(ctx->
nvencoder, &allocSurf);
1453 if (nv_status != NV_ENC_SUCCESS) {
1462 nv_status = p_nvenc->nvEncCreateBitstreamBuffer(ctx->
nvencoder, &allocOut);
1463 if (nv_status != NV_ENC_SUCCESS) {
1481 int i, res = 0, res2;
1523 NV_ENCODE_API_FUNCTION_LIST *p_nvenc = &dl_fn->
nvenc_funcs;
1525 NVENCSTATUS nv_status;
1526 uint32_t outSize = 0;
1527 char tmpHeader[256];
1528 NV_ENC_SEQUENCE_PARAM_PAYLOAD payload = { 0 };
1529 payload.version = NV_ENC_SEQUENCE_PARAM_PAYLOAD_VER;
1531 payload.spsppsBuffer = tmpHeader;
1532 payload.inBufferSize =
sizeof(tmpHeader);
1533 payload.outSPSPPSPayloadSize = &outSize;
1535 nv_status = p_nvenc->nvEncGetSequenceParams(ctx->
nvencoder, &payload);
1536 if (nv_status != NV_ENC_SUCCESS) {
1547 memcpy(avctx->
extradata, tmpHeader, outSize);
1556 NV_ENCODE_API_FUNCTION_LIST *p_nvenc = &dl_fn->
nvenc_funcs;
1561 NV_ENC_PIC_PARAMS
params = { .version = NV_ENC_PIC_PARAMS_VER,
1562 .encodePicFlags = NV_ENC_PIC_FLAG_EOS };
1568 p_nvenc->nvEncEncodePicture(ctx->
nvencoder, ¶ms);
1600 p_nvenc->nvEncDestroyEncoder(ctx->
nvencoder);
1619 nvenc_free_functions(&dl_fn->
nvenc_dl);
1620 cuda_free_functions(&dl_fn->
cuda_dl);
1638 "hw_frames_ctx must be set when using GPU frames as input\n");
1644 "hw_frames_ctx must match the GPU frame type\n");
1689 NV_ENC_LOCK_INPUT_BUFFER *lock_buffer_params,
const AVFrame *
frame)
1691 int dst_linesize[4] = {
1692 lock_buffer_params->pitch,
1693 lock_buffer_params->pitch,
1694 lock_buffer_params->pitch,
1695 lock_buffer_params->pitch
1701 dst_linesize[1] = dst_linesize[2] >>= 1;
1704 lock_buffer_params->bufferDataPtr, dst_linesize);
1722 NV_ENCODE_API_FUNCTION_LIST *p_nvenc = &dl_fn->
nvenc_funcs;
1723 NVENCSTATUS nv_status;
1728 for (first_round = 1; first_round >= 0; first_round--) {
1735 if (nv_status != NV_ENC_SUCCESS)
1736 return nvenc_print_error(avctx, nv_status,
"Failed unregistering unused input resource");
1756 NV_ENCODE_API_FUNCTION_LIST *p_nvenc = &dl_fn->
nvenc_funcs;
1759 NV_ENC_REGISTER_RESOURCE reg;
1773 reg.version = NV_ENC_REGISTER_RESOURCE_VER;
1774 reg.width = frames_ctx->
width;
1775 reg.height = frames_ctx->
height;
1777 reg.resourceToRegister = frame->
data[0];
1780 reg.resourceType = NV_ENC_INPUT_RESOURCE_TYPE_CUDADEVICEPTR;
1783 reg.resourceType = NV_ENC_INPUT_RESOURCE_TYPE_DIRECTX;
1784 reg.subResourceIndex = (intptr_t)frame->
data[1];
1788 if (reg.bufferFormat == NV_ENC_BUFFER_FORMAT_UNDEFINED) {
1794 ret = p_nvenc->nvEncRegisterResource(ctx->
nvencoder, ®);
1795 if (
ret != NV_ENC_SUCCESS) {
1811 NV_ENCODE_API_FUNCTION_LIST *p_nvenc = &dl_fn->
nvenc_funcs;
1814 NVENCSTATUS nv_status;
1831 if (nv_status != NV_ENC_SUCCESS) {
1839 nvenc_frame->
reg_idx = reg_idx;
1846 NV_ENC_LOCK_INPUT_BUFFER lockBufferParams = { 0 };
1848 lockBufferParams.version = NV_ENC_LOCK_INPUT_BUFFER_VER;
1851 nv_status = p_nvenc->nvEncLockInputBuffer(ctx->
nvencoder, &lockBufferParams);
1852 if (nv_status != NV_ENC_SUCCESS) {
1853 return nvenc_print_error(avctx, nv_status,
"Failed locking nvenc input buffer");
1856 nvenc_frame->
pitch = lockBufferParams.pitch;
1860 if (nv_status != NV_ENC_SUCCESS) {
1869 NV_ENC_PIC_PARAMS *
params,
1870 NV_ENC_SEI_PAYLOAD *sei_data,
1877 params->codecPicParams.h264PicParams.sliceMode =
1879 params->codecPicParams.h264PicParams.sliceModeData =
1880 ctx->
encode_config.encodeCodecConfig.h264Config.sliceModeData;
1881 if (sei_count > 0) {
1882 params->codecPicParams.h264PicParams.seiPayloadArray = sei_data;
1883 params->codecPicParams.h264PicParams.seiPayloadArrayCnt = sei_count;
1888 params->codecPicParams.hevcPicParams.sliceMode =
1890 params->codecPicParams.hevcPicParams.sliceModeData =
1891 ctx->
encode_config.encodeCodecConfig.hevcConfig.sliceModeData;
1892 if (sei_count > 0) {
1893 params->codecPicParams.hevcPicParams.seiPayloadArray = sei_data;
1894 params->codecPicParams.hevcPicParams.seiPayloadArrayCnt = sei_count;
1916 NV_ENC_LOCK_BITSTREAM *
params,
1921 pkt->
pts = params->outputTimeStamp;
1933 NV_ENCODE_API_FUNCTION_LIST *p_nvenc = &dl_fn->
nvenc_funcs;
1935 uint32_t slice_mode_data;
1936 uint32_t *slice_offsets =
NULL;
1937 NV_ENC_LOCK_BITSTREAM lock_params = { 0 };
1938 NVENCSTATUS nv_status;
1945 slice_mode_data = ctx->
encode_config.encodeCodecConfig.h264Config.sliceModeData;
1948 slice_mode_data = ctx->
encode_config.encodeCodecConfig.hevcConfig.sliceModeData;
1955 slice_offsets =
av_mallocz(slice_mode_data *
sizeof(*slice_offsets));
1957 if (!slice_offsets) {
1962 lock_params.version = NV_ENC_LOCK_BITSTREAM_VER;
1964 lock_params.doNotWait = 0;
1966 lock_params.sliceOffsets = slice_offsets;
1968 nv_status = p_nvenc->nvEncLockBitstream(ctx->
nvencoder, &lock_params);
1969 if (nv_status != NV_ENC_SUCCESS) {
1981 memcpy(pkt->
data, lock_params.bitstreamBufferPtr, lock_params.bitstreamSizeInBytes);
1984 if (nv_status != NV_ENC_SUCCESS) {
1985 res =
nvenc_print_error(avctx, nv_status,
"Failed unlocking bitstream buffer, expect the gates of mordor to open");
1994 if (nv_status != NV_ENC_SUCCESS) {
2008 switch (lock_params.pictureType) {
2009 case NV_ENC_PIC_TYPE_IDR:
2011 case NV_ENC_PIC_TYPE_I:
2014 case NV_ENC_PIC_TYPE_P:
2017 case NV_ENC_PIC_TYPE_B:
2020 case NV_ENC_PIC_TYPE_BI:
2024 av_log(avctx,
AV_LOG_ERROR,
"Unknown picture type encountered, expect the output to be broken.\n");
2025 av_log(avctx,
AV_LOG_ERROR,
"Please report this error and include as much information on how to reproduce it as possible.\n");
2030 #if FF_API_CODED_FRAME 2059 int nb_ready, nb_pending;
2064 return nb_ready > 0;
2065 return (nb_ready > 0) && (nb_ready + nb_pending >= ctx->
async_depth);
2074 NV_ENC_RECONFIGURE_PARAMS
params = { 0 };
2075 int needs_reconfig = 0;
2076 int needs_encode_config = 0;
2077 int reconfig_bitrate = 0, reconfig_dar = 0;
2080 params.version = NV_ENC_RECONFIGURE_PARAMS_VER;
2086 "aspect ratio change (DAR): %d:%d -> %d:%d\n",
2090 params.reInitEncodeParams.darHeight = dh;
2091 params.reInitEncodeParams.darWidth = dw;
2098 if (avctx->
bit_rate > 0 && params.reInitEncodeParams.encodeConfig->rcParams.averageBitRate != avctx->
bit_rate) {
2100 "avg bitrate change: %d -> %d\n",
2101 params.reInitEncodeParams.encodeConfig->rcParams.averageBitRate,
2104 params.reInitEncodeParams.encodeConfig->rcParams.averageBitRate = avctx->
bit_rate;
2105 reconfig_bitrate = 1;
2110 "max bitrate change: %d -> %d\n",
2111 params.reInitEncodeParams.encodeConfig->rcParams.maxBitRate,
2114 params.reInitEncodeParams.encodeConfig->rcParams.maxBitRate = avctx->
rc_max_rate;
2115 reconfig_bitrate = 1;
2120 "vbv buffer size change: %d -> %d\n",
2121 params.reInitEncodeParams.encodeConfig->rcParams.vbvBufferSize,
2124 params.reInitEncodeParams.encodeConfig->rcParams.vbvBufferSize = avctx->
rc_buffer_size;
2125 reconfig_bitrate = 1;
2128 if (reconfig_bitrate) {
2129 params.resetEncoder = 1;
2130 params.forceIDR = 1;
2132 needs_encode_config = 1;
2137 if (!needs_encode_config)
2138 params.reInitEncodeParams.encodeConfig =
NULL;
2140 if (needs_reconfig) {
2141 ret = p_nvenc->nvEncReconfigureEncoder(ctx->
nvencoder, ¶ms);
2142 if (ret != NV_ENC_SUCCESS) {
2150 if (reconfig_bitrate) {
2151 ctx->
encode_config.rcParams.averageBitRate = params.reInitEncodeParams.encodeConfig->rcParams.averageBitRate;
2152 ctx->
encode_config.rcParams.maxBitRate = params.reInitEncodeParams.encodeConfig->rcParams.maxBitRate;
2153 ctx->
encode_config.rcParams.vbvBufferSize = params.reInitEncodeParams.encodeConfig->rcParams.vbvBufferSize;
2162 NVENCSTATUS nv_status;
2165 NV_ENC_SEI_PAYLOAD sei_data[8];
2171 NV_ENCODE_API_FUNCTION_LIST *p_nvenc = &dl_fn->
nvenc_funcs;
2173 NV_ENC_PIC_PARAMS pic_params = { 0 };
2174 pic_params.version = NV_ENC_PIC_PARAMS_VER;
2179 if (frame && frame->
buf[0]) {
2200 pic_params.bufferFmt = in_surf->
format;
2201 pic_params.inputWidth = in_surf->
width;
2202 pic_params.inputHeight = in_surf->
height;
2203 pic_params.inputPitch = in_surf->
pitch;
2208 pic_params.pictureStruct = NV_ENC_PIC_STRUCT_FIELD_TOP_BOTTOM;
2210 pic_params.pictureStruct = NV_ENC_PIC_STRUCT_FIELD_BOTTOM_TOP;
2212 pic_params.pictureStruct = NV_ENC_PIC_STRUCT_FRAME;
2216 pic_params.encodePicFlags =
2217 ctx->
forced_idr ? NV_ENC_PIC_FLAG_FORCEIDR : NV_ENC_PIC_FLAG_FORCEINTRA;
2219 pic_params.encodePicFlags = 0;
2222 pic_params.inputTimeStamp = frame->
pts;
2225 void *a53_data =
NULL;
2226 size_t a53_size = 0;
2233 sei_data[sei_count].payloadSize = (uint32_t)a53_size;
2234 sei_data[sei_count].payloadType = 4;
2235 sei_data[sei_count].payload = (
uint8_t*)a53_data;
2241 void *tc_data =
NULL;
2249 sei_data[sei_count].payloadSize = (uint32_t)tc_size;
2251 sei_data[sei_count].payload = (
uint8_t*)tc_data;
2258 pic_params.encodePicFlags = NV_ENC_PIC_FLAG_EOS;
2265 nv_status = p_nvenc->nvEncEncodePicture(ctx->
nvencoder, &pic_params);
2267 for ( i = 0; i < sei_count; i++)
2274 if (nv_status != NV_ENC_SUCCESS &&
2275 nv_status != NV_ENC_ERR_NEED_MORE_INPUT)
2278 if (frame && frame->
buf[0]) {
2284 if (nv_status == NV_ENC_SUCCESS) {
2306 if (!frame->
buf[0]) {
#define FF_PROFILE_H264_MAIN
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
const struct AVCodec * codec
av_cold int ff_nvenc_encode_close(AVCodecContext *avctx)
static enum AVPixelFormat pix_fmt
NV_ENC_BUFFER_FORMAT format
This structure describes decoded (raw) audio or video data.
static av_cold int nvenc_setup_codec_config(AVCodecContext *avctx)
AVFifoBuffer * timestamp_list
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
static void flush(AVCodecContext *avctx)
NvencFunctions * nvenc_dl
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
static av_cold void set_vbr(AVCodecContext *avctx)
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
#define AV_LOG_WARNING
Something somehow does not look correct.
int64_t bit_rate
the average bitrate
#define RC_MODE_DEPRECATED
Memory handling functions.
static av_cold int nvenc_setup_device(AVCodecContext *avctx)
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
static int nvenc_send_frame(AVCodecContext *avctx, const AVFrame *frame)
#define HW_CONFIG_ENCODER_FRAMES(format, device_type_)
int max_bitrate
Maximum bitrate of the stream, in bits per second.
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
enum AVColorRange color_range
MPEG vs JPEG YUV range.
const AVCodecHWConfigInternal *const ff_nvenc_hw_configs[]
Timecode which conforms to SMPTE ST 12-1.
#define PRESET_ALIAS(alias, name,...)
static av_cold int nvenc_setup_surfaces(AVCodecContext *avctx)
NV_ENCODE_API_FUNCTION_LIST nvenc_funcs
NvencDynLoadFunctions nvenc_dload_funcs
ID3D11Device * d3d11_device
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
int width
The allocated dimensions of the frames in this pool.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
int ff_nvenc_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
static av_cold int nvenc_recalc_surfaces(AVCodecContext *avctx)
static void error(const char *err)
float i_quant_offset
qscale offset between P and I-frames
static void nvenc_override_rate_control(AVCodecContext *avctx)
static NvencSurface * get_free_frame(NvencContext *ctx)
static av_cold void nvenc_setup_rate_control(AVCodecContext *avctx)
int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int(*func)(void *, void *, int))
Feed data from a user-supplied callback to an AVFifoBuffer.
#define FF_PROFILE_H264_HIGH_444_PREDICTIVE
NV_ENC_INPUT_PTR input_surface
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
AVBufferRef * hw_frames_ctx
For hwaccel-format frames, this should be a reference to the AVHWFramesContext describing the frame...
struct NvencContext::@116 registered_frames[MAX_REGISTERED_FRAMES]
#define FF_PROFILE_H264_BASELINE
AVFifoBuffer * unused_surface_queue
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
enum AVPixelFormat ff_nvenc_pix_fmts[]
static const struct @110 nvenc_errors[]
float b_quant_factor
qscale factor between IP and B-frames If > 0 then the last P-frame quantizer will be used (q= lastp_q...
static int nvenc_pop_context(AVCodecContext *avctx)
#define FF_PROFILE_HEVC_MAIN
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
NV_ENC_INITIALIZE_PARAMS init_encode_params
void * hwctx
The format-specific data, allocated and freed by libavutil along with this context.
static av_cold int nvenc_alloc_surface(AVCodecContext *avctx, int idx)
ID3D11Device * device
Device used for texture creation and access.
#define MAX_REGISTERED_FRAMES
static av_cold int nvenc_setup_extradata(AVCodecContext *avctx)
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
#define AVERROR_EOF
End of file.
#define AV_LOG_VERBOSE
Detailed information.
static int nvenc_check_capabilities(AVCodecContext *avctx)
#define AV_PIX_FMT_YUV444P16
static int nvenc_register_frame(AVCodecContext *avctx, const AVFrame *frame)
int buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
#define HW_CONFIG_ENCODER_DEVICE(format, device_type_)
int ff_alloc_a53_sei(const AVFrame *frame, size_t prefix_len, void **data, size_t *sei_size)
Check AVFrame for A53 side data and allocate and fill SEI message with A53 info.
#define FF_PROFILE_HEVC_MAIN_10
AVFifoBuffer * output_surface_ready_queue
CUcontext cu_context_internal
An API-specific header for AV_HWDEVICE_TYPE_CUDA.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
static av_cold int nvenc_open_session(AVCodecContext *avctx)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int has_b_frames
Size of the frame reordering buffer in the decoder.
static void timestamp_queue_enqueue(AVFifoBuffer *queue, int64_t timestamp)
static __device__ float fabs(float a)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
int qmax
maximum quantizer
static int nvenc_map_error(NVENCSTATUS err, const char **desc)
ATSC A53 Part 4 Closed Captions.
int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void(*func)(void *, void *, int))
Feed data from an AVFifoBuffer to a user-supplied callback.
#define FF_PROFILE_H264_HIGH
int flags
AV_CODEC_FLAG_*.
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
simple assert() macros that are a bit more flexible than ISO C assert().
#define AV_PIX_FMT_0BGR32
float i_quant_factor
qscale factor between P- and I-frames If > 0 then the last P-frame quantizer will be used (q = lastp_...
enum AVHWDeviceType type
This field identifies the underlying API used for hardware access.
static av_cold int nvenc_setup_hevc_config(AVCodecContext *avctx)
static NV_ENC_BUFFER_FORMAT nvenc_map_buffer_format(enum AVPixelFormat pix_fmt)
static av_cold void set_constqp(AVCodecContext *avctx)
void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4], const uint8_t *src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)
Copy image in src_data to dst_data.
int flags
A combination of AV_PKT_FLAG values.
int rc_buffer_size
decoder bitstream buffer size
static int nvenc_check_codec_support(AVCodecContext *avctx)
int refs
number of reference frames
enum AVPictureType pict_type
Picture type of the frame.
static int nvenc_upload_frame(AVCodecContext *avctx, const AVFrame *frame, NvencSurface *nvenc_frame)
NV_ENC_REGISTERED_PTR regptr
static av_cold int nvenc_setup_encoder(AVCodecContext *avctx)
#define AVERROR_BUFFER_TOO_SMALL
Buffer too small.
AVHWDeviceContext * device_ctx
The parent AVHWDeviceContext.
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
av_cold int ff_nvenc_encode_init(AVCodecContext *avctx)
static int process_output_surface(AVCodecContext *avctx, AVPacket *pkt, NvencSurface *tmpoutsurf)
int width
picture width / height.
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static int nvenc_copy_frame(AVCodecContext *avctx, NvencSurface *nv_surface, NV_ENC_LOCK_INPUT_BUFFER *lock_buffer_params, const AVFrame *frame)
#define IS_YUV444(pix_fmt)
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
AVFifoBuffer * output_surface_queue
static void nvenc_print_driver_requirement(AVCodecContext *avctx, int level)
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
HW acceleration through CUDA.
static av_cold int nvenc_setup_h264_config(AVCodecContext *avctx)
int draining
checks API usage: after codec draining, flush is required to resume operation
#define FF_ARRAY_ELEMS(a)
enum AVPixelFormat data_pix_fmt
#define IS_10BIT(pix_fmt)
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
This structure describes the bitrate properties of an encoded bitstream.
#define AV_LOG_INFO
Standard information.
NV_ENC_CONFIG encode_config
static int nvenc_push_context(AVCodecContext *avctx)
int av_image_fill_pointers(uint8_t *data[4], enum AVPixelFormat pix_fmt, int height, uint8_t *ptr, const int linesizes[4])
Fill plane data pointers for an image with pixel format pix_fmt and height height.
int av_fifo_size(const AVFifoBuffer *f)
Return the amount of data in bytes in the AVFifoBuffer, that is the amount of data you can read from ...
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
main external API structure.
uint8_t * data
The data buffer.
int qmin
minimum quantizer
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
This struct is allocated as AVHWDeviceContext.hwctx.
static int nvenc_check_cap(AVCodecContext *avctx, NV_ENC_CAPS cap)
enum AVColorSpace colorspace
YUV colorspace type.
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
This struct describes a set or pool of "hardware" frames (i.e.
av_cold void ff_nvenc_encode_flush(AVCodecContext *avctx)
float b_quant_offset
qscale offset between IP and B-frames
static int nvenc_find_free_reg_resource(AVCodecContext *avctx)
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
int global_quality
Global quality for codecs which cannot change it per frame.
#define flags(name, subs,...)
static void compute_dar(AVCodecContext *avctx, int *dw, int *dh)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static void nvenc_codec_specific_pic_params(AVCodecContext *avctx, NV_ENC_PIC_PARAMS *params, NV_ENC_SEI_PAYLOAD *sei_data, int sei_count)
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Hardware surfaces for Direct3D11.
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
int ff_alloc_timecode_sei(const AVFrame *frame, AVRational rate, size_t prefix_len, void **data, size_t *sei_size)
Check AVFrame for S12M timecode side data and allocate and fill TC SEI message with timecode info...
static int64_t timestamp_queue_dequeue(AVFifoBuffer *queue)
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
#define FF_DISABLE_DEPRECATION_WARNINGS
common internal api header.
static int output_ready(AVCodecContext *avctx, int flush)
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
NV_ENC_MAP_INPUT_RESOURCE in_map
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
static void reconfig_encoder(AVCodecContext *avctx, const AVFrame *frame)
#define FF_PROFILE_HEVC_REXT
static int nvenc_set_timestamp(AVCodecContext *avctx, NV_ENC_LOCK_BITSTREAM *params, AVPacket *pkt)
#define xf(width, name, var, range_min, range_max, subs,...)
#define FF_ENABLE_DEPRECATION_WARNINGS
AVFifoBuffer * av_fifo_alloc(unsigned int size)
Initialize an AVFifoBuffer.
int top_field_first
If the content is interlaced, is top field displayed first.
static av_cold int nvenc_load_libraries(AVCodecContext *avctx)
static av_cold int nvenc_check_device(AVCodecContext *avctx, int idx)
int avg_bitrate
Average bitrate of the stream, in bits per second.
struct AVCodecInternal * internal
Private context used for internal data.
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
This struct is allocated as AVHWDeviceContext.hwctx.
static int nvenc_print_error(AVCodecContext *avctx, NVENCSTATUS err, const char *error_string)
static av_cold void set_lossless(AVCodecContext *avctx)
void av_fifo_freep(AVFifoBuffer **f)
Free an AVFifoBuffer and reset pointer to NULL.
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
#define FFSWAP(type, a, b)
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
void av_fifo_reset(AVFifoBuffer *f)
Reset the AVFifoBuffer to the state right after av_fifo_alloc, in particular it is emptied...
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
#define AVERROR_EXTERNAL
Generic error in an external library.
AVPixelFormat
Pixel format.
static double val(void *priv, double ch)
This structure stores compressed data.
NV_ENC_OUTPUT_PTR output_surface
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
#define AV_NOPTS_VALUE
Undefined timestamp value.
static void nvenc_map_preset(NvencContext *ctx)
#define AV_PIX_FMT_0RGB32
int64_t rc_max_rate
maximum bitrate
int ff_encode_get_frame(AVCodecContext *avctx, AVFrame *frame)
Called by encoders to get the next frame for encoding.
void * av_mallocz_array(size_t nmemb, size_t size)