On Sat, May 30, 2015 at 4:40 PM, Luca Barbato <[email protected]> wrote:
> Partially based on the work of Timo Rothenpieler <[email protected]>
> ---
imho commit log could be just "Implement a NVenc encoder"
> +
> + guids = av_malloc(count * sizeof(GUID));
> +
memory check please
> + ret = nv->nvEncGetEncodeGUIDs(ctx->nvenc_ctx, guids, count, &count);
> + if (ret != NV_ENC_SUCCESS) {
> + ret = AVERROR(ENOSYS);
> + goto fail;
> + }
> +
> + ret = AVERROR(ENOSYS);
> + for (i = 0; i < count; i++) {
> + if (!memcmp(&guids[i], &ctx->params.encodeGUID, sizeof(*guids))) {
> + ret = 0;
> + break;
> + }
> + }
> +
> +fail:
> + av_free(guids);
> +
> + return ret;
> +}
> +
> +static int nvenc_check_cap(AVCodecContext *avctx, NV_ENC_CAPS cap)
> +{
> + NVENCContext *ctx = avctx->priv_data;
> + NV_ENCODE_API_FUNCTION_LIST *nv = &ctx->nvel.nvenc_funcs;
> + NV_ENC_CAPS_PARAM params = { 0 };
> + int ret, val = 0;
> +
> + params.version = NV_ENC_CAPS_PARAM_VER;
> + params.capsToQuery = cap;
> +
> + ret = nv->nvEncGetEncodeCaps(ctx->nvenc_ctx, ctx->params.encodeGUID,
> ¶ms, &val);
> +
> + if (ret == NV_ENC_SUCCESS)
> + return val;
> + return 0;
> +}
> +
> +static int nvenc_check_capabilities(AVCodecContext *avctx)
> +{
> + int ret;
> +
> + ret = nvenc_check_codec_support(avctx);
> + if (ret < 0) {
> + av_log(avctx, AV_LOG_VERBOSE, "Codec not supported\n");
> + return ret;
> + }
> +
> + ret = nvenc_check_cap(avctx, NV_ENC_CAPS_SUPPORT_YUV444_ENCODE);
> + if (avctx->pix_fmt == AV_PIX_FMT_YUV444P && ret <= 0) {
> + av_log(avctx, AV_LOG_VERBOSE, "YUV444P not supported\n");
> + return AVERROR(ENOSYS);
> + }
> +
> + ret = nvenc_check_cap(avctx, NV_ENC_CAPS_WIDTH_MAX);
> + if (ret < avctx->width) {
> + av_log(avctx, AV_LOG_VERBOSE, "Width %d exceeds %d\n",
> + avctx->width, ret);
> + return AVERROR(ENOSYS);
> + }
> +
> + ret = nvenc_check_cap(avctx, NV_ENC_CAPS_HEIGHT_MAX);
> + if (ret < avctx->height) {
> + av_log(avctx, AV_LOG_VERBOSE, "Height %d exceeds %d\n",
> + avctx->height, ret);
> + return AVERROR(ENOSYS);
> + }
> +
> + ret = nvenc_check_cap(avctx, NV_ENC_CAPS_NUM_MAX_BFRAMES);
> + if (ret < avctx->max_b_frames) {
> + av_log(avctx, AV_LOG_VERBOSE, "Max b-frames %d exceed %d\n",
> + avctx->max_b_frames, ret);
> +
> + return AVERROR(ENOSYS);
> + }
> +
> + return 0;
> +}
> +
> +static int nvenc_check_device(AVCodecContext *avctx, int idx)
> +{
> + NVENCContext *ctx = avctx->priv_data;
> + NVENCLibraryContext *nvel = &ctx->nvel;
> + char name[128] = { 0 };
> + int major, minor, ret;
> + CUdevice cu_device;
> + CUcontext dummy;
> + int loglevel = AV_LOG_VERBOSE;
> +
> + if (ctx->device == LIST_DEVICES)
> + loglevel = AV_LOG_INFO;
> +
> + ret = nvel->cu_device_get(&cu_device, idx);
> + if (ret != CUDA_SUCCESS) {
> + av_log(avctx, AV_LOG_ERROR,
> + "Cannot access the CUDA device %d\n",
> + idx);
> + return -1;
> + }
> +
> + ret = nvel->cu_device_get_name(name, sizeof(name), cu_device);
> + if (ret != CUDA_SUCCESS)
> + return -1;
> +
> + ret = nvel->cu_device_compute_capability(&major, &minor, cu_device);
> + if (ret != CUDA_SUCCESS)
> + return -1;
> +
> + av_log(avctx, loglevel, "Device %d [%s] ", cu_device, name);
> +
> + if (((major << 4) | minor) < NVENC_CAP)
> + goto fail;
> +
> + ret = nvel->cu_ctx_create(&ctx->cu_context, 0, cu_device);
> + if (ret != CUDA_SUCCESS)
> + goto fail;
> +
> + ret = nvel->cu_ctx_pop_current(&dummy);
> + if (ret != CUDA_SUCCESS)
> + goto fail2;
> +
> + if ((ret = nvenc_open_session(avctx)) < 0)
> + goto fail2;
> +
> + if ((ret = nvenc_check_capabilities(avctx)) < 0)
> + goto fail3;
> +
> + av_log(avctx, loglevel, "supports NVENC\n");
> +
> + if (ctx->device == cu_device || ctx->device == ANY_DEVICE)
> + return 0;
> +
> +fail3:
> + nvel->nvenc_funcs.nvEncDestroyEncoder(ctx->nvenc_ctx);
> + ctx->nvenc_ctx = NULL;
> +
> +fail2:
> + nvel->cu_ctx_destroy(ctx->cu_context);
> + ctx->cu_context = NULL;
> +
> +fail:
> + if (ret != 0)
> + av_log(avctx, loglevel, "does not support NVENC (major %d minor
> %d)\n",
> + major, minor);
> +
> + return AVERROR(ENOSYS);
> +}
> +
> +static int nvenc_setup_device(AVCodecContext *avctx)
> +{
> + NVENCContext *ctx = avctx->priv_data;
> + NVENCLibraryContext *nvel = &ctx->nvel;
> + int i, nb_devices = 0;
> +
> + if ((nvel->cu_init(0)) != CUDA_SUCCESS) {
> + av_log(avctx, AV_LOG_ERROR,
> + "Cannot init CUDA\n");
> + return AVERROR_UNKNOWN;
> + }
> +
> + if ((nvel->cu_device_get_count(&nb_devices)) != CUDA_SUCCESS) {
> + av_log(avctx, AV_LOG_ERROR,
> + "Cannot enumerate the CUDA devices\n");
> + return AVERROR_UNKNOWN;
> + }
> +
> + switch (avctx->codec->id) {
> + case AV_CODEC_ID_H264:
> + ctx->params.encodeGUID = NV_ENC_CODEC_H264_GUID;
> + break;
> + case AV_CODEC_ID_HEVC:
> + ctx->params.encodeGUID = NV_ENC_CODEC_HEVC_GUID;
> + break;
> + default:
> + return AVERROR_BUG;
> + }
> +
> + for (i = 0; i < nb_devices; ++i) {
> + if ((nvenc_check_device(avctx, i)) >= 0 && ctx->device !=
> LIST_DEVICES)
> + return 0;
> + }
> +
> + if (ctx->device == LIST_DEVICES)
> + return AVERROR_EXIT;
> +
> + return AVERROR(ENOSYS);
> +}
> +
> +typedef struct GUIDTuple {
> + const GUID guid;
> + int flags;
> +} GUIDTuple;
> +
> +static int nvec_map_preset(NVENCContext *ctx)
> +{
> + GUIDTuple presets[] = {
> + { NV_ENC_PRESET_DEFAULT_GUID },
> + { NV_ENC_PRESET_HP_GUID },
> + { NV_ENC_PRESET_HQ_GUID },
> + { NV_ENC_PRESET_BD_GUID },
> + { NV_ENC_PRESET_LOW_LATENCY_DEFAULT_GUID, NVENC_LOWLATENCY },
> + { NV_ENC_PRESET_LOW_LATENCY_HP_GUID, NVENC_LOWLATENCY },
> + { NV_ENC_PRESET_LOW_LATENCY_HQ_GUID, NVENC_LOWLATENCY },
> + { NV_ENC_PRESET_LOSSLESS_DEFAULT_GUID, NVENC_LOSSLESS },
> + { NV_ENC_PRESET_LOSSLESS_HP_GUID, NVENC_LOSSLESS },
> + { { 0 } }
> + };
> +
> + GUIDTuple *t = &presets[ctx->preset];
> +
> + ctx->params.presetGUID = t->guid;
> + ctx->flags = t->flags;
> +
> + return AVERROR(EINVAL);
> +}
> +
> +static void set_constqp(AVCodecContext *avctx, NV_ENC_RC_PARAMS *rc)
> +{
> + rc->rateControlMode = NV_ENC_PARAMS_RC_CONSTQP;
> + rc->constQP.qpInterB = avctx->global_quality;
> + rc->constQP.qpInterP = avctx->global_quality;
> + rc->constQP.qpIntra = avctx->global_quality;
> +}
> +
> +static void set_vbr(AVCodecContext *avctx, NV_ENC_RC_PARAMS *rc)
> +{
> + if (avctx->qmin >= 0) {
> + rc->enableMinQP = 1;
> + rc->minQP.qpInterB = avctx->qmin;
> + rc->minQP.qpInterP = avctx->qmin;
> + rc->minQP.qpIntra = avctx->qmin;
> + }
> +
> + if (avctx->qmax >= 0) {
> + rc->enableMaxQP = 1;
> + rc->maxQP.qpInterB = avctx->qmax;
> + rc->maxQP.qpInterP = avctx->qmax;
> + rc->maxQP.qpIntra = avctx->qmax;
> + }
> +}
> +
> +static void nvenc_override_rate_control(AVCodecContext *avctx,
> + NV_ENC_RC_PARAMS *rc)
> +{
> + NVENCContext *ctx = avctx->priv_data;
> +
> + switch (ctx->rc) {
> + case NV_ENC_PARAMS_RC_CONSTQP:
> + if (avctx->global_quality < 0) {
> + av_log(avctx, AV_LOG_WARNING,
> + "The constant quality rate-control requires "
> + "the 'global_quality' option set.\n");
> + return;
> + }
> + set_constqp(avctx, rc);
> + return;
> + case NV_ENC_PARAMS_RC_2_PASS_VBR:
> + case NV_ENC_PARAMS_RC_VBR:
> + if (avctx->qmin < 0 && avctx->qmax < 0) {
> + av_log(avctx, AV_LOG_WARNING,
> + "The variable bitrate rate-control requires "
> + "the 'qmin' and/or 'qmax' option set.\n");
> + return;
> + }
> + case NV_ENC_PARAMS_RC_VBR_MINQP:
> + if (avctx->qmin < 0) {
> + av_log(avctx, AV_LOG_WARNING,
> + "The variable bitrate rate-control requires "
> + "the 'qmin' option set.\n");
> + return;
> + }
> + set_vbr(avctx, rc);
> + break;
> + case NV_ENC_PARAMS_RC_CBR:
> + break;
> + case NV_ENC_PARAMS_RC_2_PASS_QUALITY:
> + case NV_ENC_PARAMS_RC_2_PASS_FRAMESIZE_CAP:
> + if (!(ctx->flags & NVENC_LOWLATENCY)) {
> + av_log(avctx, AV_LOG_WARNING,
> + "The multipass rate-control requires "
> + "a low-latency preset.\n");
> + return;
> + }
> + }
> +
> + rc->rateControlMode = ctx->rc;
> +}
> +
> +static void nvenc_setup_rate_control(AVCodecContext *avctx)
> +{
> + NVENCContext *ctx = avctx->priv_data;
> + NV_ENC_RC_PARAMS *rc = &ctx->config.rcParams;
> +
> + if (avctx->bit_rate > 0)
> + rc->averageBitRate = avctx->bit_rate;
> +
> + if (avctx->rc_max_rate > 0)
> + rc->maxBitRate = avctx->rc_max_rate;
> +
> + if (ctx->rc > 0) {
> + nvenc_override_rate_control(avctx, rc);
> + } else if (avctx->global_quality > 0) {
> + set_constqp(avctx, rc);
> + } else if (avctx->qmin >= 0 && avctx->qmax >= 0) {
> + rc->rateControlMode = NV_ENC_PARAMS_RC_VBR;
> + set_vbr(avctx, rc);
> + }
> +
> + if (avctx->rc_buffer_size > 0)
> + rc->vbvBufferSize = avctx->rc_buffer_size;
> +
> + if (rc->averageBitRate > 0)
> + avctx->bit_rate = rc->averageBitRate;
> +}
> +
> +static int nvenc_setup_h264_config(AVCodecContext *avctx)
> +{
> + NVENCContext *ctx = avctx->priv_data;
> + NV_ENC_CONFIG *cc = &ctx->config;
> + NV_ENC_CONFIG_H264 *h264 =
> &cc->encodeCodecConfig.h264Config;
> + NV_ENC_CONFIG_H264_VUI_PARAMETERS *vui = &h264->h264VUIParameters;
> +
> + vui->colourDescriptionPresentFlag = 1;
> + vui->videoSignalTypePresentFlag = 1;
> +
> + vui->colourMatrix = avctx->colorspace;
> + vui->colourPrimaries = avctx->color_primaries;
> + vui->transferCharacteristics = avctx->color_trc;
> +
> + vui->videoFullRangeFlag = avctx->color_range == AVCOL_RANGE_JPEG;
> +
> + h264->disableSPSPPS = (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) ? 1 : 0;
> + h264->repeatSPSPPS = (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) ? 0 : 1;
> +
> + h264->maxNumRefFrames = avctx->refs;
> + h264->idrPeriod = cc->gopLength;
> +
> + if (ctx->profile)
> + avctx->profile = ctx->profile;
> +
> + if (avctx->pix_fmt == AV_PIX_FMT_YUV444P)
> + h264->chromaFormatIDC = 3;
> + else
> + h264->chromaFormatIDC = 1;
> +
> + switch (ctx->profile) {
> + case NV_ENC_H264_PROFILE_BASELINE:
> + cc->profileGUID = NV_ENC_H264_PROFILE_BASELINE_GUID;
> + break;
> + case NV_ENC_H264_PROFILE_MAIN:
> + cc->profileGUID = NV_ENC_H264_PROFILE_MAIN_GUID;
> + break;
> + case NV_ENC_H264_PROFILE_HIGH:
> + cc->profileGUID = NV_ENC_H264_PROFILE_HIGH_GUID;
> + break;
> + case NV_ENC_H264_PROFILE_HIGH_444:
> + cc->profileGUID = NV_ENC_H264_PROFILE_HIGH_444_GUID;
> + break;
> + case NV_ENC_H264_PROFILE_CONSTRAINED_HIGH:
> + cc->profileGUID = NV_ENC_H264_PROFILE_CONSTRAINED_HIGH_GUID;
> + break;
> + }
> +
> + h264->level = ctx->level;
> +
> + return 0;
> +}
> +
> +static int nvenc_setup_hevc_config(AVCodecContext *avctx)
> +{
> + NVENCContext *ctx = avctx->priv_data;
> + NV_ENC_CONFIG *cc = &ctx->config;
> + NV_ENC_CONFIG_HEVC *hevc =
> &cc->encodeCodecConfig.hevcConfig;
> +
> + hevc->disableSPSPPS = (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) ? 1 : 0;
> + hevc->repeatSPSPPS = (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) ? 0 : 1;
> +
> + hevc->maxNumRefFramesInDPB = avctx->refs;
> + hevc->idrPeriod = cc->gopLength;
> +
> + /* No other profile is supported in the current SDK version 5 */
> + cc->profileGUID = NV_ENC_HEVC_PROFILE_MAIN_GUID;
> + avctx->profile = FF_PROFILE_HEVC_MAIN;
> +
> + if (ctx->level) {
> + hevc->level = ctx->level;
> + } else {
> + hevc->level = NV_ENC_LEVEL_AUTOSELECT;
> + }
> +
> + if (ctx->tier) {
> + hevc->tier = ctx->tier;
> + }
> +
> + return 0;
> +}
> +static int nvenc_setup_codec_config(AVCodecContext *avctx)
> +{
> + switch (avctx->codec->id) {
> + case AV_CODEC_ID_H264:
> + return nvenc_setup_h264_config(avctx);
> + case AV_CODEC_ID_HEVC:
> + return nvenc_setup_hevc_config(avctx);
> + }
> + return 0;
> +}
> +
> +static int nvenc_setup_encoder(AVCodecContext *avctx)
> +{
> + NVENCContext *ctx = avctx->priv_data;
> + NV_ENCODE_API_FUNCTION_LIST *nv = &ctx->nvel.nvenc_funcs;
> + NV_ENC_PRESET_CONFIG preset_cfg = { 0 };
> + int ret;
> +
> + ctx->params.version = NV_ENC_INITIALIZE_PARAMS_VER;
> +
> + ctx->params.encodeHeight = avctx->height;
> + ctx->params.encodeWidth = avctx->width;
> +
> + if (avctx->sample_aspect_ratio.num &&
> + avctx->sample_aspect_ratio.den &&
> + (avctx->sample_aspect_ratio.num != 1 ||
> + avctx->sample_aspect_ratio.num != 1)) {
> + av_reduce(&ctx->params.darWidth,
> + &ctx->params.darHeight,
> + avctx->width * avctx->sample_aspect_ratio.num,
> + avctx->height * avctx->sample_aspect_ratio.den,
> + INT_MAX / 8);
> + } else {
> + ctx->params.darHeight = avctx->height;
> + ctx->params.darWidth = avctx->width;
> + }
> +
> + ctx->params.frameRateNum = avctx->time_base.den;
> + ctx->params.frameRateDen = avctx->time_base.num * avctx->ticks_per_frame;
> +
> + ctx->params.enableEncodeAsync = 0;
> + ctx->params.enablePTD = 1;
> +
> + ctx->params.encodeConfig = &ctx->config;
> +
> + nvec_map_preset(ctx);
> +
> + preset_cfg.version = NV_ENC_PRESET_CONFIG_VER;
> + preset_cfg.presetCfg.version = NV_ENC_CONFIG_VER;
> +
> + ret = nv->nvEncGetEncodePresetConfig(ctx->nvenc_ctx,
> + ctx->params.encodeGUID,
> + ctx->params.presetGUID,
> + &preset_cfg);
> + if (ret != NV_ENC_SUCCESS) {
> + av_log(avctx, AV_LOG_ERROR,
> + "Cannot get the preset configuration\n");
> + return AVERROR_UNKNOWN;
> + }
> +
> + memcpy(&ctx->config, &preset_cfg.presetCfg, sizeof(ctx->config));
> +
> + ctx->config.version = NV_ENC_CONFIG_VER;
> +
> + if (avctx->gop_size > 0) {
> + if (avctx->max_b_frames > 0) {
> + ctx->last_dts = -2;
> + /* 0 is intra-only,
> + * 1 is I/P only,
> + * 2 is one B Frame,
> + * 3 two B frames, and so on. */
> + ctx->config.frameIntervalP = avctx->max_b_frames + 1;
> + } else if (avctx->max_b_frames == 0) {
> + ctx->config.frameIntervalP = 1;
> + }
> + ctx->config.gopLength = avctx->gop_size;
> + } else if (avctx->gop_size == 0) {
> + ctx->config.frameIntervalP = 0;
> + ctx->config.gopLength = 1;
> + }
> +
> + if (ctx->config.frameIntervalP > 1)
> + avctx->max_b_frames = ctx->config.frameIntervalP - 1;
> +
> + nvenc_setup_rate_control(avctx);
> +
> + if (avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
> + ctx->config.frameFieldMode = NV_ENC_PARAMS_FRAME_FIELD_MODE_FIELD;
> + } else {
> + ctx->config.frameFieldMode = NV_ENC_PARAMS_FRAME_FIELD_MODE_FRAME;
> + }
> +
> + if ((ret = nvenc_setup_codec_config(avctx)) < 0)
> + return ret;
> +
> + ret = nv->nvEncInitializeEncoder(ctx->nvenc_ctx, &ctx->params);
> + if (ret != NV_ENC_SUCCESS) {
> + av_log(avctx, AV_LOG_ERROR, "Cannot initialize the decoder");
> + return AVERROR_UNKNOWN;
> + }
> +
> + return 0;
> +}
> +
> +static int nvenc_alloc_surface(AVCodecContext *avctx, int idx)
> +{
> + NVENCContext *ctx = avctx->priv_data;
> + NV_ENCODE_API_FUNCTION_LIST *nv = &ctx->nvel.nvenc_funcs;
> + int ret;
> + NV_ENC_CREATE_INPUT_BUFFER in_buffer = { 0 };
> + NV_ENC_CREATE_BITSTREAM_BUFFER out_buffer = { 0 };
> +
> + in_buffer.version = NV_ENC_CREATE_INPUT_BUFFER_VER;
> + out_buffer.version = NV_ENC_CREATE_BITSTREAM_BUFFER_VER;
> +
> + in_buffer.width = avctx->width;
> + in_buffer.height = avctx->height;
> +
> + in_buffer.memoryHeap = NV_ENC_MEMORY_HEAP_SYSMEM_UNCACHED;
> +
> + switch (avctx->pix_fmt) {
> + case AV_PIX_FMT_YUV420P:
> + in_buffer.bufferFmt = NV_ENC_BUFFER_FORMAT_YV12_PL;
> + break;
> + case AV_PIX_FMT_NV12:
> + in_buffer.bufferFmt = NV_ENC_BUFFER_FORMAT_NV12_PL;
> + break;
> + case AV_PIX_FMT_YUV444P:
> + in_buffer.bufferFmt = NV_ENC_BUFFER_FORMAT_YUV444_PL;
> + break;
> + default:
> + return AVERROR_BUG;
> + }
> +
> + ret = nv->nvEncCreateInputBuffer(ctx->nvenc_ctx, &in_buffer);
> + if (ret != NV_ENC_SUCCESS) {
> + av_log(avctx, AV_LOG_ERROR, "CreateInputBuffer failed\n");
> + return AVERROR_UNKNOWN;
> + }
> +
> + ctx->in[idx].in = in_buffer.inputBuffer;
> + ctx->in[idx].format = in_buffer.bufferFmt;
> +
> + /* 1MB is large enough to hold most output frames.
> + * NVENC increases this automaticaly if it's not enough. */
> + out_buffer.size = BITSTREAM_BUFFER_SIZE;
> +
> + out_buffer.memoryHeap = NV_ENC_MEMORY_HEAP_SYSMEM_UNCACHED;
> +
> + ret = nv->nvEncCreateBitstreamBuffer(ctx->nvenc_ctx, &out_buffer);
> + if (ret != NV_ENC_SUCCESS) {
> + av_log(avctx, AV_LOG_ERROR, "CreateBitstreamBuffer failed\n");
> + return AVERROR_UNKNOWN;
> + }
> +
> + ctx->out[idx].out = out_buffer.bitstreamBuffer;
> + ctx->out[idx].busy = 0;
> +
> + return 0;
> +}
> +
> +static int nvenc_setup_surfaces(AVCodecContext *avctx)
> +{
> + NVENCContext *ctx = avctx->priv_data;
> + int i, ret;
> +
> + ctx->nb_surfaces = FFMAX(4 + avctx->max_b_frames,
> + ctx->nb_surfaces);
> +
> + ctx->in = av_mallocz(ctx->nb_surfaces * sizeof(*ctx->in));
> + if (!ctx->in)
> + return AVERROR(ENOMEM);
> +
> + ctx->out = av_mallocz(ctx->nb_surfaces * sizeof(*ctx->out));
> + if (!ctx->out)
> + return AVERROR(ENOMEM);
> +
> + ctx->timestamps = av_fifo_alloc(ctx->nb_surfaces * sizeof(int64_t));
> + if (!ctx->timestamps)
> + return AVERROR(ENOMEM);
> + ctx->pending = av_fifo_alloc(ctx->nb_surfaces * sizeof(ctx->out));
> + if (!ctx->pending)
> + return AVERROR(ENOMEM);
> + ctx->ready = av_fifo_alloc(ctx->nb_surfaces * sizeof(ctx->out));
> + if (!ctx->ready)
> + return AVERROR(ENOMEM);
> +
> + for (i = 0; i < ctx->nb_surfaces; i++) {
> + if ((ret = nvenc_alloc_surface(avctx, i)) < 0)
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +#define EXTRADATA_SIZE 512
> +
> +static int nvenc_setup_extradata(AVCodecContext *avctx)
> +{
> + NVENCContext *ctx = avctx->priv_data;
> + NV_ENCODE_API_FUNCTION_LIST *nv = &ctx->nvel.nvenc_funcs;
> + NV_ENC_SEQUENCE_PARAM_PAYLOAD payload = { 0 };
> + int ret;
> +
> + avctx->extradata = av_mallocz(EXTRADATA_SIZE +
> FF_INPUT_BUFFER_PADDING_SIZE);
> + if (!avctx->extradata)
> + return AVERROR(ENOMEM);
> +
> + payload.version = NV_ENC_SEQUENCE_PARAM_PAYLOAD_VER;
> + payload.spsppsBuffer = avctx->extradata;
> + payload.inBufferSize = EXTRADATA_SIZE;
> + payload.outSPSPPSPayloadSize = &avctx->extradata_size;
> +
> + ret = nv->nvEncGetSequenceParams(ctx->nvenc_ctx, &payload);
> + if (ret != NV_ENC_SUCCESS) {
> + av_log(avctx, AV_LOG_ERROR, "Cannot get the extradata\n");
> + return AVERROR_UNKNOWN;
> + }
> +
> + return 0;
> +}
> +
> +av_cold int ff_nvenc_encode_close(AVCodecContext *avctx)
> +{
> + NVENCContext *ctx = avctx->priv_data;
> + NV_ENCODE_API_FUNCTION_LIST *nv = &ctx->nvel.nvenc_funcs;
> + int i;
> +
> + av_frame_free(&avctx->coded_frame);
> +
> + if (ctx->in) {
> + for (i = 0; i < ctx->nb_surfaces; ++i) {
> + nv->nvEncDestroyInputBuffer(ctx->nvenc_ctx, ctx->in[i].in);
> + nv->nvEncDestroyBitstreamBuffer(ctx->nvenc_ctx, ctx->out[i].out);
> + }
> + }
> +
> + av_freep(&ctx->in);
> + av_freep(&ctx->out);
> +
> + if (ctx->nvenc_ctx)
> + nv->nvEncDestroyEncoder(ctx->nvenc_ctx);
> +
> + if (ctx->cu_context)
> + ctx->nvel.cu_ctx_destroy(ctx->cu_context);
> +
> + if (ctx->nvel.nvenc)
> + dlclose(ctx->nvel.nvenc);
> +
> + if (ctx->nvel.cuda)
> + dlclose(ctx->nvel.cuda);
> +
> + return 0;
> +}
> +
> +av_cold int ff_nvenc_encode_init(AVCodecContext *avctx)
> +{
> + int ret;
> +
> + if ((ret = nvenc_load_libraries(avctx)) < 0)
> + return ret;
> +
> + if ((ret = nvenc_setup_device(avctx)) < 0)
> + return ret;
> +
> + if ((ret = nvenc_setup_encoder(avctx)) < 0)
> + return ret;
> +
> + if ((ret = nvenc_setup_surfaces(avctx)) < 0)
> + return ret;
> +
> + if (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) {
> + if ((ret = nvenc_setup_extradata(avctx)) < 0)
> + return ret;
> + }
> +
> + avctx->coded_frame = av_frame_alloc();
> + if (!avctx->coded_frame)
> + return AVERROR(ENOMEM);
> +
> + return 0;
> +}
> +
> +static NVENCInputSurface *get_input_surface(NVENCContext *ctx)
> +{
> + int i;
> +
> + for (i = 0; i < ctx->nb_surfaces; i++) {
> + if (!ctx->in[i].locked) {
> + ctx->in[i].locked = 1;
> + return &ctx->in[i];
> + }
> + }
> +
> + return NULL;
> +}
> +
> +static NVENCOutputSurface *get_output_surface(NVENCContext *ctx)
> +{
> + int i;
> +
> + for (i = 0; i < ctx->nb_surfaces; i++) {
> + if (!ctx->out[i].busy) {
> + return &ctx->out[i];
> + }
> + }
> +
> + abort();
> + return NULL;
> +}
> +
> +static int nvenc_copy_frame(NV_ENC_LOCK_INPUT_BUFFER *in, const AVFrame
> *frame)
> +{
> + uint8_t *buf = in->bufferDataPtr;
> + int off = frame->height * in->pitch;
> +
> + switch (frame->format) {
> + case AV_PIX_FMT_YUV420P:
> + av_image_copy_plane(buf, in->pitch,
> + frame->data[0], frame->linesize[0],
> + frame->width, frame->height);
> + buf += off;
> +
> + av_image_copy_plane(buf, in->pitch >> 1,
> + frame->data[2], frame->linesize[2],
> + frame->width >> 1, frame->height >> 1);
> +
> + buf += off >> 2;
> +
> + av_image_copy_plane(buf, in->pitch >> 1,
> + frame->data[1], frame->linesize[1],
> + frame->width >> 1, frame->height >> 1);
> + break;
> + case AV_PIX_FMT_NV12:
> + av_image_copy_plane(buf, in->pitch,
> + frame->data[0], frame->linesize[0],
> + frame->width, frame->height);
> + buf += off;
> +
> + av_image_copy_plane(buf, in->pitch >> 1,
> + frame->data[1], frame->linesize[1],
> + frame->width >> 1, frame->height >> 1);
> + break;
> + case AV_PIX_FMT_YUV444P:
> + av_image_copy_plane(buf, in->pitch,
> + frame->data[0], frame->linesize[0],
> + frame->width, frame->height);
> + buf += off;
> +
> + av_image_copy_plane(buf, in->pitch,
> + frame->data[1], frame->linesize[1],
> + frame->width, frame->height);
> + buf += off;
> +
> + av_image_copy_plane(buf, in->pitch,
> + frame->data[2], frame->linesize[2],
> + frame->width, frame->height);
> + break;
> + default:
> + return AVERROR_BUG;
> + }
> +
> + return 0;
> +}
> +
> +static int nvenc_enqueue_frame(AVCodecContext *avctx, const AVFrame *frame,
> + NVENCInputSurface **in_surf)
> +{
> + NVENCContext *ctx = avctx->priv_data;
> + NV_ENCODE_API_FUNCTION_LIST *nv = &ctx->nvel.nvenc_funcs;
> + NV_ENC_LOCK_INPUT_BUFFER params = { 0 };
> + NVENCInputSurface *in = get_input_surface(ctx);
> + int ret;
> +
> + if (!in)
> + return AVERROR_BUG;
> +
> + params.version = NV_ENC_LOCK_INPUT_BUFFER_VER;
> + params.inputBuffer = in->in;
> +
> +
> + ret = nv->nvEncLockInputBuffer(ctx->nvenc_ctx, ¶ms);
> + if (ret != NV_ENC_SUCCESS) {
> + av_log(avctx, AV_LOG_ERROR, "Cannot lock the buffer %p.\n",
> + in);
> + return AVERROR_UNKNOWN;
> + }
> +
> + ret = nvenc_copy_frame(¶ms, frame);
> + if (ret < 0)
> + goto fail;
> +
> + ret = nv->nvEncUnlockInputBuffer(ctx->nvenc_ctx, in->in);
> + if (ret != NV_ENC_SUCCESS) {
> + av_log(avctx, AV_LOG_ERROR, "Cannot unlock the buffer %p.\n",
> + in);
> + return AVERROR_UNKNOWN;
> + }
> +
> + *in_surf = in;
> +
> + return 0;
> +
> +fail:
> + nv->nvEncUnlockInputBuffer(ctx->nvenc_ctx, in->in);
> +
> + return ret;
> +}
> +
> +static void nvenc_codec_specific_pic_params(AVCodecContext *avctx,
> + NV_ENC_PIC_PARAMS *params)
> +{
> + NVENCContext *ctx = avctx->priv_data;
> +
> + switch (avctx->codec->id) {
> + case AV_CODEC_ID_H264:
> + params->codecPicParams.h264PicParams.sliceMode =
> + ctx->config.encodeCodecConfig.h264Config.sliceMode;
> + params->codecPicParams.h264PicParams.sliceModeData =
> + ctx->config.encodeCodecConfig.h264Config.sliceModeData;
> + break;
> + case AV_CODEC_ID_HEVC:
> + params->codecPicParams.hevcPicParams.sliceMode =
> + ctx->config.encodeCodecConfig.hevcConfig.sliceMode;
> + params->codecPicParams.hevcPicParams.sliceModeData =
> + ctx->config.encodeCodecConfig.hevcConfig.sliceModeData;
> + break;
> + }
> +}
> +
> +static inline int nvenc_enqueue_timestamp(AVFifoBuffer *f, int64_t pts)
> +{
> + return av_fifo_generic_write(f, &pts, sizeof(pts), NULL);
> +}
> +
> +static inline int nvenc_dequeue_timestamp(AVFifoBuffer *f, int64_t *pts)
> +{
> + return av_fifo_generic_read(f, pts, sizeof(*pts), NULL);
> +}
> +
> +static inline int nvenc_enqueue_surface(AVFifoBuffer *f,
> + NVENCOutputSurface *surf)
> +{
> + surf->busy = 1;
> + return av_fifo_generic_write(f, &surf, sizeof(surf), NULL);
> +}
> +
> +static inline int nvenc_dequeue_surface(AVFifoBuffer *f,
> + NVENCOutputSurface **surf)
> +{
> + return av_fifo_generic_read(f, surf, sizeof(*surf), NULL);
> +}
> +
> +static int nvenc_set_timestamp(NVENCContext *ctx,
> + NV_ENC_LOCK_BITSTREAM *params,
> + AVPacket *pkt)
> +{
> + int ret;
> +
> + pkt->pts = params->outputTimeStamp;
> + pkt->duration = params->outputDuration;
> +
> + ret = nvenc_dequeue_timestamp(ctx->timestamps, &pkt->dts);
> + if (ret < 0)
> + return ret;
> +
> + return 0;
> +}
> +
> +static int nvenc_get_frame(AVCodecContext *avctx, AVPacket *pkt)
> +{
> + NVENCContext *ctx = avctx->priv_data;
> + NV_ENCODE_API_FUNCTION_LIST *nv = &ctx->nvel.nvenc_funcs;
> + NV_ENC_LOCK_BITSTREAM params = { 0 };
> + NVENCOutputSurface *out = NULL;
> + int ret;
> +
> + ret = nvenc_dequeue_surface(ctx->pending, &out);
> + if (ret)
> + return ret;
> +
> + params.version = NV_ENC_LOCK_BITSTREAM_VER;
> + params.outputBitstream = out->out;
> +
> + ret = nv->nvEncLockBitstream(ctx->nvenc_ctx, ¶ms);
> + if (ret < 0)
> + return AVERROR_UNKNOWN;
> +
> + ret = ff_alloc_packet(pkt, params.bitstreamSizeInBytes);
> + if (ret < 0)
> + return ret;
> +
> + memcpy(pkt->data, params.bitstreamBufferPtr, pkt->size);
> +
> + ret = nv->nvEncUnlockBitstream(ctx->nvenc_ctx, out->out);
> + if (ret < 0)
> + return AVERROR_UNKNOWN;
> +
> + out->busy = out->in->locked = 0;
> +
> + nvenc_set_timestamp(ctx, ¶ms, pkt);
should you check for the return value here?
I'll give it a spin on coverity
--
Vittorio
_______________________________________________
libav-devel mailing list
[email protected]
https://lists.libav.org/mailman/listinfo/libav-devel
