Go to the documentation of this file.
24 #include <EbSvtAv1ErrorCodes.h>
25 #include <EbSvtAv1Enc.h>
75 { EB_ErrorNone, 0,
"success" },
76 { EB_ErrorInsufficientResources,
AVERROR(ENOMEM),
"insufficient resources" },
77 { EB_ErrorUndefined,
AVERROR(EINVAL),
"undefined error" },
78 { EB_ErrorInvalidComponent,
AVERROR(EINVAL),
"invalid component" },
79 { EB_ErrorBadParameter,
AVERROR(EINVAL),
"bad parameter" },
80 { EB_ErrorDestroyThreadFailed,
AVERROR_EXTERNAL,
"failed to destroy thread" },
81 { EB_ErrorSemaphoreUnresponsive,
AVERROR_EXTERNAL,
"semaphore unresponsive" },
82 { EB_ErrorDestroySemaphoreFailed,
AVERROR_EXTERNAL,
"failed to destroy semaphore"},
86 { EB_NoErrorEmptyQueue,
AVERROR(EAGAIN),
"empty queue" },
100 *
desc =
"unknown error";
105 const char *error_string)
117 const size_t luma_size =
config->source_width *
config->source_height *
118 (
config->encoder_bit_depth > 8 ? 2 : 1);
120 EbSvtIOFormat *in_data;
122 svt_enc->
raw_size = luma_size * 3 / 2;
130 if (!svt_enc->
in_buf->p_buffer)
148 param->enc_mode = svt_enc->
enc_mode;
151 param->target_bit_rate = avctx->
bit_rate;
153 param->rate_control_mode = 1;
155 param->rate_control_mode = 2;
157 param->max_qp_allowed = avctx->
qmax;
158 param->min_qp_allowed = avctx->
qmin;
162 param->maximum_buffer_size_ms =
166 if (svt_enc->
crf > 0) {
167 param->qp = svt_enc->
crf;
168 param->rate_control_mode = 0;
169 }
else if (svt_enc->
qp > 0) {
170 param->qp = svt_enc->
qp;
171 param->rate_control_mode = 0;
172 param->enable_adaptive_quantization = 0;
179 param->transfer_characteristics = avctx->
color_trc;
186 #if SVT_AV1_CHECK_VERSION(1, 0, 0)
193 param->chroma_sample_position = EB_CSP_VERTICAL;
196 param->chroma_sample_position = EB_CSP_COLOCATED;
203 "Specified chroma sample location %s is unsupported "
204 "on the AV1 bit stream level. Usage of a container that "
205 "allows passing this information - such as Matroska - "
214 param->profile = avctx->
profile;
217 param->level = avctx->
level;
225 param->intra_period_length = avctx->
gop_size - 1;
227 #if SVT_AV1_CHECK_VERSION(1, 1, 0)
237 param->force_key_frames = 1;
247 #if FF_API_TICKS_PER_FRAME
257 #if SVT_AV1_CHECK_VERSION(0, 9, 1)
259 EbErrorType
ret = svt_av1_enc_parse_parameter(param, en->
key, en->
value);
260 if (
ret != EB_ErrorNone) {
270 av_log(avctx,
level,
"svt-params needs libavcodec to be compiled with SVT-AV1 "
271 "headers >= 0.9.1.\n");
277 param->source_width = avctx->
width;
278 param->source_height = avctx->
height;
280 param->encoder_bit_depth =
desc->comp[0].depth;
282 if (
desc->log2_chroma_w == 1 &&
desc->log2_chroma_h == 1)
283 param->encoder_color_format = EB_YUV420;
284 else if (
desc->log2_chroma_w == 1 &&
desc->log2_chroma_h == 0)
285 param->encoder_color_format = EB_YUV422;
286 else if (!
desc->log2_chroma_w && !
desc->log2_chroma_h)
287 param->encoder_color_format = EB_YUV444;
293 if ((param->encoder_color_format == EB_YUV422 || param->encoder_bit_depth > 10)
297 }
else if (param->encoder_color_format == EB_YUV444 && param->profile !=
AV_PROFILE_AV1_HIGH) {
302 avctx->
bit_rate = param->rate_control_mode > 0 ?
303 param->target_bit_rate : 0;
322 EbBufferHeaderType *header_ptr)
324 EbSvtIOFormat *in_data = (EbSvtIOFormat *)header_ptr->p_buffer;
325 ptrdiff_t linesizes[4];
327 int bytes_shift = param->encoder_bit_depth > 8 ? 1 : 0;
330 for (
int i = 0;
i < 4;
i++)
339 for (
int i = 0;
i < 4;
i++) {
367 if (svt_ret != EB_ErrorNone) {
368 return svt_print_error(avctx, svt_ret,
"Error initializing encoder handle");
378 if (svt_ret != EB_ErrorNone) {
379 return svt_print_error(avctx, svt_ret,
"Error setting encoder parameters");
382 svt_ret = svt_av1_enc_init(svt_enc->
svt_handle);
383 if (svt_ret != EB_ErrorNone) {
388 EbBufferHeaderType *headerPtr =
NULL;
390 svt_ret = svt_av1_enc_stream_header(svt_enc->
svt_handle, &headerPtr);
391 if (svt_ret != EB_ErrorNone) {
392 return svt_print_error(avctx, svt_ret,
"Error building stream header");
399 "Cannot allocate AV1 header of size %d.\n", avctx->
extradata_size);
405 svt_ret = svt_av1_enc_stream_header_release(headerPtr);
406 if (svt_ret != EB_ErrorNone) {
421 EbBufferHeaderType *headerPtr = svt_enc->
in_buf;
425 EbBufferHeaderType headerPtrLast;
430 memset(&headerPtrLast, 0,
sizeof(headerPtrLast));
431 headerPtrLast.pic_type = EB_AV1_INVALID_PICTURE;
432 headerPtrLast.flags = EB_BUFFERFLAG_EOS;
434 svt_av1_enc_send_picture(svt_enc->
svt_handle, &headerPtrLast);
443 headerPtr->flags = 0;
444 headerPtr->p_app_private =
NULL;
449 headerPtr->pic_type = EB_AV1_KEY_PICTURE;
453 headerPtr->pic_type = EB_AV1_INVALID_PICTURE;
458 headerPtr->pic_type = EB_AV1_KEY_PICTURE;
460 svt_av1_enc_send_picture(svt_enc->
svt_handle, headerPtr);
468 const int max_frames = 8;
471 if (filled_len > svt_enc->
raw_size * max_frames) {
492 EbBufferHeaderType *headerPtr;
496 int ret = 0, pict_type;
513 if (svt_ret == EB_NoErrorEmptyQueue)
516 #if SVT_AV1_CHECK_VERSION(2, 0, 0)
517 if (headerPtr->flags & EB_BUFFERFLAG_EOS) {
519 svt_av1_enc_release_out_buffer(&headerPtr);
527 svt_av1_enc_release_out_buffer(&headerPtr);
533 memcpy(
pkt->
data, headerPtr->p_buffer, headerPtr->n_filled_len);
536 pkt->
size = headerPtr->n_filled_len;
537 pkt->
pts = headerPtr->pts;
538 pkt->
dts = headerPtr->dts;
540 switch (headerPtr->pic_type) {
541 case EB_AV1_KEY_PICTURE:
544 case EB_AV1_INTRA_ONLY_PICTURE:
547 case EB_AV1_INVALID_PICTURE:
555 if (headerPtr->pic_type == EB_AV1_NON_REF_PICTURE)
558 #if !(SVT_AV1_CHECK_VERSION(2, 0, 0))
559 if (headerPtr->flags & EB_BUFFERFLAG_EOS)
565 svt_av1_enc_release_out_buffer(&headerPtr);
576 svt_av1_enc_deinit_handle(svt_enc->
svt_handle);
589 #define OFFSET(x) offsetof(SvtContext, x)
590 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
592 {
"preset",
"Encoding preset",
597 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
598 { .i64 = value }, 0, 0, VE, .unit = "avctx.level"
599 {
LEVEL(
"2.0", 20) },
600 {
LEVEL(
"2.1", 21) },
601 {
LEVEL(
"2.2", 22) },
602 {
LEVEL(
"2.3", 23) },
603 {
LEVEL(
"3.0", 30) },
604 {
LEVEL(
"3.1", 31) },
605 {
LEVEL(
"3.2", 32) },
606 {
LEVEL(
"3.3", 33) },
607 {
LEVEL(
"4.0", 40) },
608 {
LEVEL(
"4.1", 41) },
609 {
LEVEL(
"4.2", 42) },
610 {
LEVEL(
"4.3", 43) },
611 {
LEVEL(
"5.0", 50) },
612 {
LEVEL(
"5.1", 51) },
613 {
LEVEL(
"5.2", 52) },
614 {
LEVEL(
"5.3", 53) },
615 {
LEVEL(
"6.0", 60) },
616 {
LEVEL(
"6.1", 61) },
617 {
LEVEL(
"6.2", 62) },
618 {
LEVEL(
"6.3", 63) },
619 {
LEVEL(
"7.0", 70) },
620 {
LEVEL(
"7.1", 71) },
621 {
LEVEL(
"7.2", 72) },
622 {
LEVEL(
"7.3", 73) },
625 {
"crf",
"Constant Rate Factor value",
OFFSET(crf),
627 {
"qp",
"Initial Quantizer level value",
OFFSET(qp),
629 {
"svtav1-params",
"Set the SVT-AV1 configuration using a :-separated list of key=value parameters",
OFFSET(svtav1_opts),
AV_OPT_TYPE_DICT, { 0 }, 0, 0,
VE },
643 {
"flags",
"+cgop" },
651 .
p.
name =
"libsvtav1",
665 .p.priv_class = &
class,
667 .p.wrapper_name =
"libsvtav1",
#define FF_ENABLE_DEPRECATION_WARNINGS
AVBufferPool * av_buffer_pool_init(size_t size, AVBufferRef *(*alloc)(size_t size))
Allocate and initialize a buffer pool.
#define AV_LOG_WARNING
Something somehow does not look correct.
AVPixelFormat
Pixel format.
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
#define AV_EF_EXPLODE
abort decoding on minor error detection
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
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
enum AVColorSpace colorspace
YUV colorspace type.
static const FFCodecDefault eb_enc_defaults[]
static AVBufferRef * get_output_ref(AVCodecContext *avctx, SvtContext *svt_enc, int filled_len)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
#define AVERROR_EOF
End of file.
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
#define FF_AV1_PROFILE_OPTS
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
This structure describes decoded (raw) audio or video data.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
@ AVCOL_RANGE_JPEG
Full range content.
#define AV_PIX_FMT_YUV420P10
static int eb_receive_packet(AVCodecContext *avctx, AVPacket *pkt)
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
static av_cold int eb_enc_init(AVCodecContext *avctx)
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1
static av_cold int eb_enc_close(AVCodecContext *avctx)
#define AV_PKT_FLAG_DISPOSABLE
Flag is used to indicate packets that contain frames that can be discarded by the decoder.
#define AV_PROFILE_AV1_PROFESSIONAL
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
int qmax
maximum quantizer
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
const char * av_chroma_location_name(enum AVChromaLocation location)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
AVCodec p
The public AVCodec.
static int eb_send_frame(AVCodecContext *avctx, const AVFrame *frame)
static const struct @110 svt_errors[]
int flags
AV_CODEC_FLAG_*.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define FF_ARRAY_ELEMS(a)
#define AV_PROFILE_UNKNOWN
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
#define AV_CEIL_RSHIFT(a, b)
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
int64_t rc_max_rate
maximum bitrate
This structure describes the bitrate properties of an encoded bitstream.
#define CODEC_LONG_NAME(str)
int rc_buffer_size
decoder bitstream buffer size
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
#define LIBAVUTIL_VERSION_INT
Describe the class of an AVClass context structure.
static const int sizes[][2]
enum AVColorRange color_range
MPEG vs JPEG YUV range.
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
int av_image_fill_plane_sizes(size_t sizes[4], enum AVPixelFormat pix_fmt, int height, const ptrdiff_t linesizes[4])
Fill plane sizes for an image with pixel format pix_fmt and height height.
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
#define FF_CODEC_RECEIVE_PACKET_CB(func)
int64_t bit_rate
the average bitrate
const char * av_default_item_name(void *ptr)
Return the context name.
@ AV_PICTURE_TYPE_I
Intra.
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
int level
Encoding level descriptor.
const FFCodec ff_libsvtav1_encoder
@ AVCOL_RANGE_UNSPECIFIED
#define LEVEL(name, value)
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
enum AVPictureType pict_type
Picture type of the frame.
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
static int config_enc_params(EbSvtAv1EncConfiguration *param, AVCodecContext *avctx)
EbComponentType * svt_handle
AVDictionary * svtav1_opts
@ AVCHROMA_LOC_UNSPECIFIED
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
@ AV_PICTURE_TYPE_NONE
Undefined.
static int alloc_buffer(EbSvtAv1EncConfiguration *config, SvtContext *svt_enc)
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
static const AVOption options[]
#define AVERROR_EXTERNAL
Generic error in an external library.
#define AV_PROFILE_AV1_HIGH
int flags
A combination of AV_PKT_FLAG values.
static int svt_map_error(EbErrorType eb_err, const char **desc)
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
#define i(width, name, range_min, range_max)
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
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.
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
EbSvtAv1EncConfiguration enc_params
#define AV_CODEC_FLAG_CLOSED_GOP
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
#define AV_INPUT_BUFFER_PADDING_SIZE
static int svt_print_error(void *log_ctx, EbErrorType err, const char *error_string)
main external API structure.
int qmin
minimum quantizer
static int ref[MAX_W *MAX_W]
attribute_deprecated int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
EbBufferHeaderType * in_buf
#define FF_DISABLE_DEPRECATION_WARNINGS
@ AV_PICTURE_TYPE_P
Predicted.
int ff_encode_get_frame(AVCodecContext *avctx, AVFrame *frame)
Called by encoders to get the next frame for encoding.
A reference to a data buffer.
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
This structure stores compressed data.
int width
picture width / height.
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
AVCPBProperties * ff_encode_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
static int read_in_data(EbSvtAv1EncConfiguration *param, const AVFrame *frame, EbBufferHeaderType *header_ptr)