40 #if !NVDECAPI_CHECK_VERSION(9, 0) 41 #define cudaVideoSurfaceFormat_YUV444 2 42 #define cudaVideoSurfaceFormat_YUV444_16Bit 3 104 #define CHECK_CU(x) FF_CUDA_CHECK_DL(avctx, ctx->cudl, x) 111 CUVIDDECODECAPS *caps =
NULL;
112 CUVIDDECODECREATEINFO cuinfo;
116 int old_width = avctx->
width;
117 int old_height = avctx->
height;
125 memset(&cuinfo, 0,
sizeof(cuinfo));
127 ctx->internal_error = 0;
129 avctx->coded_width = cuinfo.ulWidth =
format->coded_width;
130 avctx->coded_height = cuinfo.ulHeight =
format->coded_height;
133 cuinfo.display_area.left =
format->display_area.left +
ctx->crop.left;
134 cuinfo.display_area.top =
format->display_area.top +
ctx->crop.top;
135 cuinfo.display_area.right =
format->display_area.right -
ctx->crop.right;
136 cuinfo.display_area.bottom =
format->display_area.bottom -
ctx->crop.bottom;
139 if (
ctx->resize_expr) {
140 avctx->width =
ctx->resize.width;
141 avctx->height =
ctx->resize.height;
143 avctx->width = cuinfo.display_area.right - cuinfo.display_area.left;
144 avctx->height = cuinfo.display_area.bottom - cuinfo.display_area.top;
148 cuinfo.ulTargetWidth = avctx->width = (avctx->width + 1) & ~1;
149 cuinfo.ulTargetHeight = avctx->height = (avctx->height + 1) & ~1;
152 cuinfo.target_rect.left = 0;
153 cuinfo.target_rect.top = 0;
154 cuinfo.target_rect.right = cuinfo.ulTargetWidth;
155 cuinfo.target_rect.bottom = cuinfo.ulTargetHeight;
157 chroma_444 =
format->chroma_format == cudaVideoChromaFormat_444;
159 switch (
format->bit_depth_luma_minus8) {
176 if (!caps || !caps->bIsSupported) {
178 format->bit_depth_luma_minus8 + 8);
184 if (surface_fmt < 0) {
195 avctx->pix_fmt = surface_fmt;
198 if (avctx->hw_frames_ctx) {
212 (
AVRational){ avctx->width, avctx->height }));
214 ctx->deint_mode_current =
format->progressive_sequence
215 ? cudaVideoDeinterlaceMode_Weave
218 ctx->progressive_sequence =
format->progressive_sequence;
220 if (!
format->progressive_sequence &&
ctx->deint_mode_current == cudaVideoDeinterlaceMode_Weave)
225 if (
format->video_signal_description.video_full_range_flag)
230 avctx->color_primaries =
format->video_signal_description.color_primaries;
231 avctx->color_trc =
format->video_signal_description.transfer_characteristics;
232 avctx->colorspace =
format->video_signal_description.matrix_coefficients;
235 avctx->bit_rate =
format->bitrate;
237 if (
format->frame_rate.numerator &&
format->frame_rate.denominator) {
238 avctx->framerate.num =
format->frame_rate.numerator;
239 avctx->framerate.den =
format->frame_rate.denominator;
243 && avctx->coded_width ==
format->coded_width
244 && avctx->coded_height ==
format->coded_height
245 && avctx->width == old_width
246 && avctx->height == old_height
247 &&
ctx->chroma_format ==
format->chroma_format
251 if (
ctx->cudecoder) {
254 if (
ctx->internal_error < 0)
259 if (hwframe_ctx->pool && (
260 hwframe_ctx->width < avctx->width ||
261 hwframe_ctx->height < avctx->height ||
263 hwframe_ctx->sw_format != avctx->sw_pix_fmt)) {
264 av_log(avctx,
AV_LOG_ERROR,
"AVHWFramesContext is already initialized with incompatible parameters\n");
266 av_log(avctx,
AV_LOG_DEBUG,
"height: %d <-> %d\n", hwframe_ctx->height, avctx->height);
274 ctx->chroma_format =
format->chroma_format;
276 cuinfo.CodecType =
ctx->codec_type =
format->codec;
277 cuinfo.ChromaFormat =
format->chroma_format;
279 switch (avctx->sw_pix_fmt) {
281 cuinfo.OutputFormat = cudaVideoSurfaceFormat_NV12;
285 cuinfo.OutputFormat = cudaVideoSurfaceFormat_P016;
300 cuinfo.ulNumDecodeSurfaces =
ctx->nb_surfaces;
301 cuinfo.ulNumOutputSurfaces = 1;
302 cuinfo.ulCreationFlags = cudaVideoCreate_PreferCUVID;
303 cuinfo.bitDepthMinus8 =
format->bit_depth_luma_minus8;
304 cuinfo.DeinterlaceMode =
ctx->deint_mode_current;
306 if (
ctx->deint_mode_current != cudaVideoDeinterlaceMode_Weave && !
ctx->drop_second_field)
309 ctx->internal_error =
CHECK_CU(
ctx->cvdl->cuvidCreateDecoder(&
ctx->cudecoder, &cuinfo));
310 if (
ctx->internal_error < 0)
313 if (!hwframe_ctx->pool) {
315 hwframe_ctx->sw_format = avctx->sw_pix_fmt;
316 hwframe_ctx->width = avctx->width;
317 hwframe_ctx->height = avctx->height;
335 ctx->
key_frame[picparams->CurrPicIdx] = picparams->intra_pic_flag;
386 CUcontext
dummy, cuda_ctx = device_hwctx->cuda_ctx;
387 CUVIDSOURCEDATAPACKET cupkt;
392 if (is_flush && avpkt && avpkt->
size)
403 memset(&cupkt, 0,
sizeof(cupkt));
405 if (avpkt && avpkt->
size) {
406 cupkt.payload_size = avpkt->
size;
407 cupkt.payload = avpkt->
data;
410 cupkt.flags = CUVID_PKT_TIMESTAMP;
414 cupkt.timestamp = avpkt->
pts;
417 cupkt.flags = CUVID_PKT_ENDOFSTREAM;
451 CUcontext
dummy, cuda_ctx = device_hwctx->cuda_ctx;
452 CUdeviceptr mapped_frame = 0;
453 int ret = 0, eret = 0;
484 CUVIDPROCPARAMS params;
485 unsigned int pitch = 0;
491 memset(¶ms, 0,
sizeof(params));
492 params.progressive_frame = parsed_frame.
dispinfo.progressive_frame;
494 params.top_field_first = parsed_frame.
dispinfo.top_field_first;
517 CUDA_MEMCPY2D cpy = {
518 .srcMemoryType = CU_MEMORYTYPE_DEVICE,
519 .dstMemoryType = CU_MEMORYTYPE_DEVICE,
520 .srcDevice = mapped_frame,
521 .dstDevice = (CUdeviceptr)frame->
data[i],
529 ret =
CHECK_CU(ctx->
cudl->cuMemcpy2DAsync(&cpy, device_hwctx->stream));
540 unsigned int offset = 0;
600 frame->
pts += pts_diff;
660 }
else if (ret < 0) {
689 cuvid_free_functions(&ctx->
cvdl);
701 CUVIDDECODECAPS *caps;
702 int res8 = 0, res10 = 0, res12 = 0;
704 if (!ctx->
cvdl->cuvidGetDecoderCaps) {
705 av_log(avctx,
AV_LOG_WARNING,
"Used Nvidia driver is too old to perform a capability check.\n");
707 #
if defined(_WIN32) || defined(__CYGWIN__)
712 ". Continuing blind.\n");
713 ctx->
caps8.bIsSupported = ctx->
caps10.bIsSupported = 1;
715 ctx->
caps12.bIsSupported = 0;
720 = cuparseinfo->CodecType;
722 = cudaVideoChromaFormat_420;
724 ctx->
caps8.nBitDepthMinus8 = 0;
725 ctx->
caps10.nBitDepthMinus8 = 2;
726 ctx->
caps12.nBitDepthMinus8 = 4;
733 av_log(avctx,
AV_LOG_VERBOSE,
"8 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
735 av_log(avctx,
AV_LOG_VERBOSE,
"10 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
737 av_log(avctx,
AV_LOG_VERBOSE,
"12 bit: supported: %d, min_width: %d, max_width: %d, min_height: %d, max_height: %d\n",
757 if (!ctx->
caps8.bIsSupported) {
762 if (!caps->bIsSupported) {
767 if (probed_width > caps->nMaxWidth || probed_width < caps->nMinWidth) {
769 probed_width, caps->nMinWidth, caps->nMaxWidth);
773 if (probed_height > caps->nMaxHeight || probed_height < caps->nMinHeight) {
775 probed_height, caps->nMinHeight, caps->nMaxHeight);
779 if ((probed_width * probed_height) / 256 > caps->nMaxMBCount) {
781 (
int)(probed_width * probed_height) / 256, caps->nMaxMBCount);
794 CUVIDSOURCEDATAPACKET seq_pkt;
795 CUcontext cuda_ctx =
NULL;
807 int probed_bit_depth = 8;
811 probed_bit_depth = probe_desc->
comp[0].
depth;
839 ret = cuvid_load_functions(&ctx->
cvdl, avctx);
889 device_hwctx = device_ctx->
hwctx;
895 memset(&seq_pkt, 0,
sizeof(seq_pkt));
898 #if CONFIG_H264_CUVID_DECODER 903 #if CONFIG_HEVC_CUVID_DECODER 908 #if CONFIG_MJPEG_CUVID_DECODER 913 #if CONFIG_MPEG1_CUVID_DECODER 918 #if CONFIG_MPEG2_CUVID_DECODER 923 #if CONFIG_MPEG4_CUVID_DECODER 928 #if CONFIG_VP8_CUVID_DECODER 933 #if CONFIG_VP9_CUVID_DECODER 938 #if CONFIG_VC1_CUVID_DECODER 958 +
FFMAX(extradata_size - (
int)
sizeof(ctx->
cuparse_ext->raw_seqhdr_data), 0));
964 if (extradata_size > 0)
965 memcpy(ctx->
cuparse_ext->raw_seqhdr_data, extradata, extradata_size);
966 ctx->
cuparse_ext->format.seqhdr_data_length = extradata_size;
998 seq_pkt.payload = ctx->
cuparse_ext->raw_seqhdr_data;
999 seq_pkt.payload_size = ctx->
cuparse_ext->format.seqhdr_data_length;
1001 if (seq_pkt.payload && seq_pkt.payload_size) {
1028 CUcontext
dummy, cuda_ctx = device_hwctx->cuda_ctx;
1029 CUVIDSOURCEDATAPACKET seq_pkt = { 0 };
1032 ret =
CHECK_CU(
ctx->cudl->cuCtxPushCurrent(cuda_ctx));
1039 if (!
ctx->frame_queue) {
1044 if (
ctx->cudecoder) {
1045 ctx->cvdl->cuvidDestroyDecoder(
ctx->cudecoder);
1049 if (
ctx->cuparser) {
1050 ctx->cvdl->cuvidDestroyVideoParser(
ctx->cuparser);
1054 ret =
CHECK_CU(
ctx->cvdl->cuvidCreateVideoParser(&
ctx->cuparser, &
ctx->cuparseinfo));
1058 seq_pkt.payload =
ctx->cuparse_ext->raw_seqhdr_data;
1059 seq_pkt.payload_size =
ctx->cuparse_ext->format.seqhdr_data_length;
1061 if (seq_pkt.payload && seq_pkt.payload_size) {
1062 ret =
CHECK_CU(
ctx->cvdl->cuvidParseVideoData(
ctx->cuparser, &seq_pkt));
1071 ctx->prev_pts = INT64_MIN;
1072 ctx->decoder_flushing = 0;
1079 #define OFFSET(x) offsetof(CuvidContext, x) 1080 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM 1082 {
"deint",
"Set deinterlacing mode",
OFFSET(
deint_mode),
AV_OPT_TYPE_INT, { .i64 = cudaVideoDeinterlaceMode_Weave }, cudaVideoDeinterlaceMode_Weave, cudaVideoDeinterlaceMode_Adaptive,
VD,
"deint" },
1083 {
"weave",
"Weave deinterlacing (do nothing)", 0,
AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Weave }, 0, 0,
VD,
"deint" },
1084 {
"bob",
"Bob deinterlacing", 0,
AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Bob }, 0, 0,
VD,
"deint" },
1085 {
"adaptive",
"Adaptive deinterlacing", 0,
AV_OPT_TYPE_CONST, { .i64 = cudaVideoDeinterlaceMode_Adaptive }, 0, 0,
VD,
"deint" },
1107 #define DEFINE_CUVID_CODEC(x, X, bsf_name) \ 1108 static const AVClass x##_cuvid_class = { \ 1109 .class_name = #x "_cuvid", \ 1110 .item_name = av_default_item_name, \ 1111 .option = options, \ 1112 .version = LIBAVUTIL_VERSION_INT, \ 1114 AVCodec ff_##x##_cuvid_decoder = { \ 1115 .name = #x "_cuvid", \ 1116 .long_name = NULL_IF_CONFIG_SMALL("Nvidia CUVID " #X " decoder"), \ 1117 .type = AVMEDIA_TYPE_VIDEO, \ 1118 .id = AV_CODEC_ID_##X, \ 1119 .priv_data_size = sizeof(CuvidContext), \ 1120 .priv_class = &x##_cuvid_class, \ 1121 .init = cuvid_decode_init, \ 1122 .close = cuvid_decode_end, \ 1123 .decode = cuvid_decode_frame, \ 1124 .receive_frame = cuvid_output_frame, \ 1125 .flush = cuvid_flush, \ 1127 .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_HARDWARE, \ 1128 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_CUDA, \ 1132 AV_PIX_FMT_NONE }, \ 1133 .hw_configs = cuvid_hw_configs, \ 1134 .wrapper_name = "cuvid", \ 1137 #if CONFIG_HEVC_CUVID_DECODER 1141 #if CONFIG_H264_CUVID_DECODER 1145 #if CONFIG_MJPEG_CUVID_DECODER 1149 #if CONFIG_MPEG1_CUVID_DECODER 1153 #if CONFIG_MPEG2_CUVID_DECODER 1157 #if CONFIG_MPEG4_CUVID_DECODER 1161 #if CONFIG_VP8_CUVID_DECODER 1165 #if CONFIG_VP9_CUVID_DECODER 1169 #if CONFIG_VC1_CUVID_DECODER This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
AVCodecHWConfig public
This is the structure which will be returned to the user by avcodec_get_hw_config().
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
const struct AVCodec * codec
AVCodecParameters * par_out
Parameters of the output stream.
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
static const char * format[]
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
int coded_width
Bitstream width / height, may be different from width/height e.g.
int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
static av_cold int cuvid_decode_init(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.
AVCUDADeviceContextInternal * internal
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
CUVIDPARSERPARAMS cuparseinfo
int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
Set various frame properties from the codec context / packet data.
static av_cold int cuvid_decode_end(AVCodecContext *avctx)
static void error(const char *err)
This struct describes the properties of an encoded stream.
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.
AVBufferRef * hw_frames_ctx
For hwaccel-format frames, this should be a reference to the AVHWFramesContext describing the frame...
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
struct CuvidContext::@47 crop
static int cuvid_decode_packet(AVCodecContext *avctx, const AVPacket *avpkt)
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
enum AVPixelFormat pix_fmt
For decoders, a hardware pixel format which that decoder may be able to decode to if suitable hardwar...
AVFifoBuffer * frame_queue
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
void * hwctx
The format-specific data, allocated and freed by libavutil along with this context.
int av_hwdevice_ctx_create(AVBufferRef **pdevice_ref, enum AVHWDeviceType type, const char *device, AVDictionary *opts, int flags)
Open a device of the specified type and create an AVHWDeviceContext for it.
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
#define AVERROR_EOF
End of file.
#define AV_LOG_VERBOSE
Detailed information.
#define AV_PIX_FMT_YUV444P16
int interlaced_frame
The content of the picture is interlaced.
#define cudaVideoSurfaceFormat_YUV444
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
cudaVideoChromaFormat chroma_format
#define i(width, name, range_min, range_max)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
cudaVideoCodec codec_type
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
The codec supports this format via the hw_device_ctx interface.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
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.
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
const char * name
Name of the codec implementation.
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
static void cuvid_flush(AVCodecContext *avctx)
static const uint8_t offset[127][2]
int av_hwframe_get_buffer(AVBufferRef *hwframe_ref, AVFrame *frame, int flags)
Allocate a new frame attached to the given AVHWFramesContext.
int extradata_size
Size of the extradata content in bytes.
int av_hwframe_transfer_data(AVFrame *dst, const AVFrame *src, int flags)
Copy data to or from a hw surface.
#define cudaVideoSurfaceFormat_YUV444_16Bit
uint8_t nb_components
The number of components each pixel has, (1-4)
AVHWDeviceContext * device_ctx
The parent AVHWDeviceContext.
static int CUDAAPI cuvid_handle_video_sequence(void *opaque, CUVIDEOFORMAT *format)
int width
picture width / height.
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
static int cuvid_output_frame(AVCodecContext *avctx, AVFrame *frame)
FFmpeg internal API for CUDA.
static int CUDAAPI cuvid_handle_picture_decode(void *opaque, CUVIDPICPARAMS *picparams)
const char * bsfs
Decoding only, a comma-separated list of bitstream filters to apply to packets before decoding...
HW acceleration through CUDA.
preferred ID for MPEG-1/2 video decoding
the normal 2^n-1 "JPEG" YUV ranges
static int cuvid_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Libavcodec external API header.
int64_t pkt_duration
duration of the corresponding packet, expressed in AVStream->time_base units, 0 if unknown...
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.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
main external API structure.
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
uint8_t * data
The data buffer.
static int cuvid_test_capabilities(AVCodecContext *avctx, const CUVIDPARSERPARAMS *cuparseinfo, int probed_width, int probed_height, int bit_depth)
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
a very simple circular buffer FIFO implementation
static const AVOption options[]
static const AVCodecHWConfigInternal * cuvid_hw_configs[]
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
This struct is allocated as AVHWDeviceContext.hwctx.
Describe the class of an AVClass context structure.
Rational number (pair of numerator and denominator).
This struct describes a set or pool of "hardware" frames (i.e.
refcounted data buffer API
static enum AVPixelFormat pix_fmts[]
The codec supports this format by some internal method.
struct CuvidContext::@48 resize
CUVIDPARSERDISPINFO dispinfo
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
AVBufferRef * device_ref
A reference to the parent AVHWDeviceContext.
attribute_deprecated int64_t pkt_pts
PTS copied from the AVPacket that was decoded to produce this frame.
the normal 219*2^(n-8) "MPEG" YUV ranges
A reference to a data buffer.
#define DEFINE_CUVID_CODEC(x, X, bsf_name)
#define FF_DISABLE_DEPRECATION_WARNINGS
common internal api header.
AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
Allocate an AVHWFramesContext tied to a given device context.
static int CUDAAPI cuvid_handle_picture_display(void *opaque, CUVIDPARSERDISPINFO *dispinfo)
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
AVFifoBuffer * av_fifo_alloc(unsigned int size)
Initialize an AVFifoBuffer.
#define FF_ENABLE_DEPRECATION_WARNINGS
int top_field_first
If the content is interlaced, is top field displayed first.
struct AVCodecInternal * internal
Private context used for internal data.
int key_frame
1 -> keyframe, 0-> not
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
CUVIDEOFORMATEX * cuparse_ext
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
void av_fifo_freep(AVFifoBuffer **f)
Free an AVFifoBuffer and reset pointer to NULL.
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.
int depth
Number of bits in the component.
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
int pkt_size
size of the corresponding packet containing the compressed frame.
#define AVERROR_EXTERNAL
Generic error in an external library.
AVPixelFormat
Pixel format.
This structure stores compressed data.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
#define AV_NOPTS_VALUE
Undefined timestamp value.
static int cuvid_is_buffer_full(AVCodecContext *avctx)