#include "libavutil/fifo.h"
#include "libavutil/log.h"
#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
#include "avcodec.h"
#include "internal.h"
CuvidContext *ctx = avctx->priv_data;
AVHWFramesContext *hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
CUVIDDECODECREATEINFO cuinfo;
+ int surface_fmt;
+
+ enum AVPixelFormat pix_fmts[3] = { AV_PIX_FMT_CUDA,
+ AV_PIX_FMT_NONE, // Will be updated below
+ AV_PIX_FMT_NONE };
av_log(avctx, AV_LOG_TRACE, "pfnSequenceCallback, progressive_sequence=%d\n", format->progressive_sequence);
ctx->internal_error = 0;
+ // width and height need to be set before calling ff_get_format
avctx->width = format->display_area.right;
avctx->height = format->display_area.bottom;
+ switch (format->bit_depth_luma_minus8) {
+ case 0: // 8-bit
+ pix_fmts[1] = AV_PIX_FMT_NV12;
+ break;
+ case 2: // 10-bit
+ pix_fmts[1] = AV_PIX_FMT_P010;
+ break;
+ case 4: // 12-bit
+ pix_fmts[1] = AV_PIX_FMT_P016;
+ break;
+ default:
+ av_log(avctx, AV_LOG_ERROR, "unsupported bit depth: %d\n",
+ format->bit_depth_luma_minus8 + 8);
+ ctx->internal_error = AVERROR(EINVAL);
+ return 0;
+ }
+ surface_fmt = ff_get_format(avctx, pix_fmts);
+ if (surface_fmt < 0) {
+ av_log(avctx, AV_LOG_ERROR, "ff_get_format failed: %d\n", surface_fmt);
+ ctx->internal_error = AVERROR(EINVAL);
+ return 0;
+ }
+
+ av_log(avctx, AV_LOG_VERBOSE, "Formats: Original: %s | HW: %s | SW: %s\n",
+ av_get_pix_fmt_name(avctx->pix_fmt),
+ av_get_pix_fmt_name(surface_fmt),
+ av_get_pix_fmt_name(avctx->sw_pix_fmt));
+
+ avctx->pix_fmt = surface_fmt;
+
+ // Update our hwframe ctx, as the get_format callback might have refreshed it!
+ if (avctx->hw_frames_ctx) {
+ av_buffer_unref(&ctx->hwframe);
+
+ ctx->hwframe = av_buffer_ref(avctx->hw_frames_ctx);
+ if (!ctx->hwframe) {
+ ctx->internal_error = AVERROR(ENOMEM);
+ return 0;
+ }
+
+ hwframe_ctx = (AVHWFramesContext*)ctx->hwframe->data;
+ }
+
ff_set_sar(avctx, av_div_q(
(AVRational){ format->display_aspect_ratio.x, format->display_aspect_ratio.y },
(AVRational){ avctx->width, avctx->height }));
hwframe_ctx->width < avctx->width ||
hwframe_ctx->height < avctx->height ||
hwframe_ctx->format != AV_PIX_FMT_CUDA ||
- hwframe_ctx->sw_format != AV_PIX_FMT_NV12)) {
+ hwframe_ctx->sw_format != avctx->sw_pix_fmt)) {
av_log(avctx, AV_LOG_ERROR, "AVHWFramesContext is already initialized with incompatible parameters\n");
+ av_log(avctx, AV_LOG_DEBUG, "width: %d <-> %d\n", hwframe_ctx->width, avctx->width);
+ av_log(avctx, AV_LOG_DEBUG, "height: %d <-> %d\n", hwframe_ctx->height, avctx->height);
+ av_log(avctx, AV_LOG_DEBUG, "format: %s <-> cuda\n", av_get_pix_fmt_name(hwframe_ctx->format));
+ av_log(avctx, AV_LOG_DEBUG, "sw_format: %s <-> %s\n",
+ av_get_pix_fmt_name(hwframe_ctx->sw_format), av_get_pix_fmt_name(avctx->sw_pix_fmt));
ctx->internal_error = AVERROR(EINVAL);
return 0;
}
cuinfo.CodecType = ctx->codec_type = format->codec;
cuinfo.ChromaFormat = format->chroma_format;
- cuinfo.OutputFormat = cudaVideoSurfaceFormat_NV12;
+
+ switch (avctx->sw_pix_fmt) {
+ case AV_PIX_FMT_NV12:
+ cuinfo.OutputFormat = cudaVideoSurfaceFormat_NV12;
+ break;
+ case AV_PIX_FMT_P010:
+ case AV_PIX_FMT_P016:
+ cuinfo.OutputFormat = cudaVideoSurfaceFormat_P016;
+ break;
+ default:
+ av_log(avctx, AV_LOG_ERROR, "Output formats other than NV12, P010 or P016 are not supported\n");
+ ctx->internal_error = AVERROR(EINVAL);
+ return 0;
+ }
cuinfo.ulWidth = avctx->coded_width;
cuinfo.ulHeight = avctx->coded_height;
if (!hwframe_ctx->pool) {
hwframe_ctx->format = AV_PIX_FMT_CUDA;
- hwframe_ctx->sw_format = AV_PIX_FMT_NV12;
+ hwframe_ctx->sw_format = avctx->sw_pix_fmt;
hwframe_ctx->width = avctx->width;
hwframe_ctx->height = avctx->height;
{
AVCodecContext *avctx = opaque;
CuvidContext *ctx = avctx->priv_data;
- CuvidParsedFrame parsed_frame = { *dispinfo, 0, 0 };
+ CuvidParsedFrame parsed_frame = { { 0 } };
+ parsed_frame.dispinfo = *dispinfo;
ctx->internal_error = 0;
if (ctx->deint_mode == cudaVideoDeinterlaceMode_Weave) {
offset += avctx->coded_height;
}
- } else if (avctx->pix_fmt == AV_PIX_FMT_NV12) {
+ } else if (avctx->pix_fmt == AV_PIX_FMT_NV12 ||
+ avctx->pix_fmt == AV_PIX_FMT_P010 ||
+ avctx->pix_fmt == AV_PIX_FMT_P016) {
AVFrame *tmp_frame = av_frame_alloc();
if (!tmp_frame) {
av_log(avctx, AV_LOG_ERROR, "av_frame_alloc failed\n");
av_frame_free(&tmp_frame);
goto error;
}
-
av_frame_free(&tmp_frame);
} else {
ret = AVERROR_BUG;
return 0;
}
-static int cuvid_test_dummy_decoder(AVCodecContext *avctx, CUVIDPARSERPARAMS *cuparseinfo)
+static int cuvid_test_dummy_decoder(AVCodecContext *avctx,
+ const CUVIDPARSERPARAMS *cuparseinfo,
+ int probed_width,
+ int probed_height)
{
CuvidContext *ctx = avctx->priv_data;
CUVIDDECODECREATEINFO cuinfo;
cuinfo.ChromaFormat = cudaVideoChromaFormat_420;
cuinfo.OutputFormat = cudaVideoSurfaceFormat_NV12;
- cuinfo.ulWidth = 1280;
- cuinfo.ulHeight = 720;
+ cuinfo.ulWidth = probed_width;
+ cuinfo.ulHeight = probed_height;
cuinfo.ulTargetWidth = cuinfo.ulWidth;
cuinfo.ulTargetHeight = cuinfo.ulHeight;
AV_PIX_FMT_NV12,
AV_PIX_FMT_NONE };
+ int probed_width = avctx->coded_width ? avctx->coded_width : 1280;
+ int probed_height = avctx->coded_height ? avctx->coded_height : 720;
+
+ // Accelerated transcoding scenarios with 'ffmpeg' require that the
+ // pix_fmt be set to AV_PIX_FMT_CUDA early. The sw_pix_fmt, and the
+ // pix_fmt for non-accelerated transcoding, do not need to be correct
+ // but need to be set to something. We arbitrarily pick NV12.
ret = ff_get_format(avctx, pix_fmts);
if (ret < 0) {
av_log(avctx, AV_LOG_ERROR, "ff_get_format failed: %d\n", ret);
if (ret < 0)
goto error;
- ret = cuvid_test_dummy_decoder(avctx, &ctx->cuparseinfo);
+ ret = cuvid_test_dummy_decoder(avctx, &ctx->cuparseinfo,
+ probed_width,
+ probed_height);
if (ret < 0)
goto error;
.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING, \
.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_CUDA, \
AV_PIX_FMT_NV12, \
+ AV_PIX_FMT_P010, \
+ AV_PIX_FMT_P016, \
AV_PIX_FMT_NONE }, \
};