20 #include <va/va_enc_mpeg2.h>
67 char *
data,
size_t *data_len,
81 "%zu < %zu.\n", *data_len,
101 "type = %d.\n",
type);
109 char *
data,
size_t *data_len)
143 char *
data,
size_t *data_len)
175 VAEncSequenceParameterBufferMPEG2 *vseq =
ctx->codec_sequence_params;
176 VAEncPictureParameterBufferMPEG2 *vpic =
ctx->codec_picture_params;
177 int code, ext_n, ext_d;
179 memset(sh, 0,
sizeof(*sh));
180 memset(
se, 0,
sizeof(*
se));
181 memset(sde, 0,
sizeof(*sde));
182 memset(goph, 0,
sizeof(*goph));
183 memset(ph, 0,
sizeof(*ph));
184 memset(pce, 0,
sizeof(*pce));
187 if (
ctx->va_bit_rate > 0) {
201 switch (avctx->
level) {
229 (
AVRational) { avctx->width, avctx->height });
241 "representable, signalling square pixels instead.\n",
256 &
code, &ext_n, &ext_d, 0);
273 se->profile_and_level_indication = avctx->
profile << 4 | avctx->
level;
274 se->progressive_sequence = 1;
275 se->chroma_format = 1;
277 se->horizontal_size_extension = avctx->
width >> 12;
278 se->vertical_size_extension = avctx->
height >> 12;
280 se->bit_rate_extension = priv->
bit_rate >> 18;
282 se->low_delay =
ctx->b_per_p == 0;
284 se->frame_rate_extension_n = ext_n;
285 se->frame_rate_extension_d = ext_d;
353 *vseq = (VAEncSequenceParameterBufferMPEG2) {
354 .intra_period =
ctx->gop_size,
355 .ip_period =
ctx->b_per_p + 1,
357 .picture_width = avctx->
width,
358 .picture_height = avctx->
height,
360 .bits_per_second =
ctx->va_bit_rate,
365 .sequence_extension.bits = {
366 .profile_and_level_indication =
se->profile_and_level_indication,
367 .progressive_sequence =
se->progressive_sequence,
368 .chroma_format =
se->chroma_format,
369 .low_delay =
se->low_delay,
370 .frame_rate_extension_n =
se->frame_rate_extension_n,
371 .frame_rate_extension_d =
se->frame_rate_extension_d,
382 *vpic = (VAEncPictureParameterBufferMPEG2) {
383 .forward_reference_picture = VA_INVALID_ID,
384 .backward_reference_picture = VA_INVALID_ID,
385 .reconstructed_picture = VA_INVALID_ID,
386 .coded_buf = VA_INVALID_ID,
389 .f_code = { { 15, 15 }, { 15, 15 } },
391 .picture_coding_extension.bits = {
405 .composite_display.bits = {
455 vpic->picture_type = VAEncPictureTypeIntra;
458 vpic->picture_type = VAEncPictureTypePredictive;
462 vpic->picture_type = VAEncPictureTypeBidirectional;
471 vpic->f_code[0][0] = pce->
f_code[0][0];
472 vpic->f_code[0][1] = pce->
f_code[0][1];
473 vpic->f_code[1][0] = pce->
f_code[1][0];
474 vpic->f_code[1][1] = pce->
f_code[1][1];
505 vslice->quantiser_scale_code = qp;
522 if (
ctx->va_rc_mode == VA_RC_CQP) {
538 "%d / %d / %d for I- / P- / B-frames.\n",
550 ctx->nb_slices =
ctx->slice_block_rows;
553 ctx->roi_quant_range = 31;
571 .default_quality = 10,
573 .sequence_params_size =
sizeof(VAEncSequenceParameterBufferMPEG2),
576 .picture_params_size =
sizeof(VAEncPictureParameterBufferMPEG2),
579 .slice_params_size =
sizeof(VAEncSliceParameterBufferMPEG2),
582 .sequence_header_type = VAEncPackedHeaderSequence,
585 .picture_header_type = VAEncPackedHeaderPicture,
603 switch (avctx->
level) {
615 if (avctx->
height % 4096 == 0 || avctx->
width % 4096 == 0) {
617 "height or width divisible by 4096.\n");
621 ctx->desired_packed_headers = VA_ENC_PACKED_HEADER_SEQUENCE |
622 VA_ENC_PACKED_HEADER_PICTURE;
640 #define OFFSET(x) offsetof(VAAPIEncodeMPEG2Context, x)
641 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
646 {
"profile",
"Set profile (in profile_and_level_indication)",
650 #define PROFILE(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
651 { .i64 = value }, 0, 0, FLAGS, "profile"
656 {
"level",
"Set level (in profile_and_level_indication)",
658 { .i64 = 4 }, 0, 15,
FLAGS,
"level" },
660 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
661 { .i64 = value }, 0, 0, FLAGS, "level"
662 {
LEVEL(
"low", 10) },
663 {
LEVEL(
"main", 8) },
664 {
LEVEL(
"high_1440", 6) },
665 {
LEVEL(
"high", 4) },
675 {
"i_qfactor",
"1" },
676 {
"i_qoffset",
"0" },
677 {
"b_qfactor",
"6/5" },
678 {
"b_qoffset",
"0" },
692 .
name =
"mpeg2_vaapi",
710 .wrapper_name =
"vaapi",
static const AVCodecDefault defaults[]
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Libavcodec external API header.
#define FF_PROFILE_UNKNOWN
#define FF_PROFILE_MPEG2_SIMPLE
#define FF_PROFILE_MPEG2_MAIN
static av_cold int init(AVCodecContext *avctx)
void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
int ff_cbs_insert_unit_content(CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, void *content, AVBufferRef *content_buf)
Insert a new unit into a fragment with the given content.
void ff_cbs_fragment_reset(CodedBitstreamFragment *frag)
Free the units contained in a fragment as well as the fragment's own data buffer, but not the units a...
int ff_cbs_write_fragment_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Write the content of the fragment to its own internal buffer.
int ff_cbs_init(CodedBitstreamContext **ctx_ptr, enum AVCodecID codec_id, void *log_ctx)
Create and initialise a new context for the given codec.
void ff_cbs_fragment_free(CodedBitstreamFragment *frag)
Free the units array of a fragment in addition to what ff_cbs_fragment_reset does.
#define se(name, range_min, range_max)
@ MPEG2_START_SEQUENCE_HEADER
@ MPEG2_EXTENSION_SEQUENCE_DISPLAY
@ MPEG2_EXTENSION_PICTURE_CODING
@ MPEG2_EXTENSION_SEQUENCE
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
#define AV_CODEC_CAP_HARDWARE
Codec is backed by a hardware implementation.
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const char * av_default_item_name(void *ptr)
Return the context name.
static double av_q2d(AVRational a)
Convert an AVRational to a double.
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
#define LIBAVUTIL_VERSION_INT
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
const AVCodecHWConfigInternal *const ff_vaapi_encode_hw_configs[]
int ff_vaapi_encode_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
av_cold int ff_vaapi_encode_init(AVCodecContext *avctx)
av_cold int ff_vaapi_encode_close(AVCodecContext *avctx)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static enum AVPixelFormat pix_fmts[]
void ff_mpeg12_find_best_frame_rate(AVRational frame_rate, int *code, int *ext_n, int *ext_d, int nonstandard)
AVPixelFormat
Pixel format.
static const uint8_t header[24]
Describe the class of an AVClass context structure.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
main external API structure.
int width
picture width / height.
int rc_buffer_size
decoder bitstream buffer size
float b_quant_offset
qscale offset between IP and B-frames
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
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...
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
enum AVColorSpace colorspace
YUV colorspace type.
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
float i_quant_factor
qscale factor between P- and I-frames If > 0 then the last P-frame quantizer will be used (q = lastp_...
float i_quant_offset
qscale offset between P and I-frames
const char * name
Name of the codec implementation.
Rational number (pair of numerator and denominator).
Context structure for coded bitstream operations.
Coded bitstream fragment structure, combining one or more units.
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
size_t data_size
The number of bytes in the bitstream.
uint8_t * data
Pointer to the bitstream form of this fragment.
MPEG2RawPictureCodingExtension picture_coding
uint8_t extension_start_code
MPEG2RawSequenceDisplayExtension sequence_display
MPEG2RawSequenceExtension sequence
union MPEG2RawExtensionData::@35 data
uint8_t extension_start_code_identifier
uint8_t sub_carrier_phase
uint8_t concealment_motion_vectors
uint8_t progressive_frame
uint8_t repeat_first_field
uint8_t frame_pred_frame_dct
uint8_t composite_display_flag
uint8_t picture_structure
uint8_t intra_dc_precision
uint16_t display_vertical_size
uint8_t transfer_characteristics
uint16_t display_horizontal_size
uint8_t colour_description
uint8_t matrix_coefficients
MPEG2RawGroupOfPicturesHeader gop_header
MPEG2RawPictureHeader picture_header
unsigned int vbv_buffer_size
MPEG2RawExtensionData sequence_extension
CodedBitstreamContext * cbc
unsigned int f_code_vertical
MPEG2RawExtensionData picture_coding_extension
MPEG2RawSequenceHeader sequence_header
MPEG2RawExtensionData sequence_display_extension
unsigned int f_code_horizontal
VAAPIEncodeContext common
CodedBitstreamFragment current_fragment
void * codec_picture_params
struct VAAPIEncodePicture * refs[MAX_PICTURE_REFERENCES]
VASurfaceID recon_surface
void * codec_slice_params
const VAAPIEncodeProfile * profiles
#define VAAPI_ENCODE_COMMON_OPTIONS
#define VAAPI_ENCODE_RC_OPTIONS
static av_cold int vaapi_encode_mpeg2_init(AVCodecContext *avctx)
static const VAAPIEncodeType vaapi_encode_type_mpeg2
AVCodec ff_mpeg2_vaapi_encoder
static const AVCodecDefault vaapi_encode_mpeg2_defaults[]
static int vaapi_encode_mpeg2_write_picture_header(AVCodecContext *avctx, VAAPIEncodePicture *pic, char *data, size_t *data_len)
static av_cold int vaapi_encode_mpeg2_configure(AVCodecContext *avctx)
static const VAAPIEncodeProfile vaapi_encode_mpeg2_profiles[]
static int vaapi_encode_mpeg2_write_sequence_header(AVCodecContext *avctx, char *data, size_t *data_len)
static const AVOption vaapi_encode_mpeg2_options[]
#define LEVEL(name, value)
static int vaapi_encode_mpeg2_init_picture_params(AVCodecContext *avctx, VAAPIEncodePicture *pic)
static int vaapi_encode_mpeg2_write_fragment(AVCodecContext *avctx, char *data, size_t *data_len, CodedBitstreamFragment *frag)
static av_cold int vaapi_encode_mpeg2_close(AVCodecContext *avctx)
static int vaapi_encode_mpeg2_init_sequence_params(AVCodecContext *avctx)
#define PROFILE(name, value)
static int vaapi_encode_mpeg2_init_slice_params(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodeSlice *slice)
static int vaapi_encode_mpeg2_add_header(AVCodecContext *avctx, CodedBitstreamFragment *frag, int type, void *header)
static const AVClass vaapi_encode_mpeg2_class