26 #define VPX_DISABLE_CTRL_TYPECHECKS 1
27 #define VPX_CODEC_DISABLE_COMPAT 1
28 #include <vpx/vpx_encoder.h>
29 #include <vpx/vp8cx.h>
33 #include "libavutil/avassert.h"
34 #include "libavutil/base64.h"
35 #include "libavutil/common.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/mathematics.h"
38 #include "libavutil/opt.h"
60 typedef struct VP8EncoderContext {
62 struct vpx_codec_ctx encoder;
63 struct vpx_image rawimg;
64 struct vpx_codec_ctx encoder_alpha;
65 struct vpx_image rawimg_alpha;
67 struct vpx_fixed_buf twopass_stats;
79 #define VP8F_ERROR_RESILIENT 0x00000001
80 #define VP8F_AUTO_ALT_REF 0x00000002
96 [VP8E_UPD_ENTROPY] =
"VP8E_UPD_ENTROPY",
97 [VP8E_UPD_REFERENCE] =
"VP8E_UPD_REFERENCE",
98 [VP8E_USE_REFERENCE] =
"VP8E_USE_REFERENCE",
99 [VP8E_SET_ROI_MAP] =
"VP8E_SET_ROI_MAP",
100 [VP8E_SET_ACTIVEMAP] =
"VP8E_SET_ACTIVEMAP",
101 [VP8E_SET_SCALEMODE] =
"VP8E_SET_SCALEMODE",
102 [VP8E_SET_CPUUSED] =
"VP8E_SET_CPUUSED",
103 [VP8E_SET_ENABLEAUTOALTREF] =
"VP8E_SET_ENABLEAUTOALTREF",
104 [VP8E_SET_NOISE_SENSITIVITY] =
"VP8E_SET_NOISE_SENSITIVITY",
105 [VP8E_SET_SHARPNESS] =
"VP8E_SET_SHARPNESS",
106 [VP8E_SET_STATIC_THRESHOLD] =
"VP8E_SET_STATIC_THRESHOLD",
107 [VP8E_SET_TOKEN_PARTITIONS] =
"VP8E_SET_TOKEN_PARTITIONS",
108 [VP8E_GET_LAST_QUANTIZER] =
"VP8E_GET_LAST_QUANTIZER",
109 [VP8E_SET_ARNR_MAXFRAMES] =
"VP8E_SET_ARNR_MAXFRAMES",
110 [VP8E_SET_ARNR_STRENGTH] =
"VP8E_SET_ARNR_STRENGTH",
111 [VP8E_SET_ARNR_TYPE] =
"VP8E_SET_ARNR_TYPE",
112 [VP8E_SET_CQ_LEVEL] =
"VP8E_SET_CQ_LEVEL",
113 [VP8E_SET_MAX_INTRA_BITRATE_PCT] =
"VP8E_SET_MAX_INTRA_BITRATE_PCT",
119 const char *error = vpx_codec_error(&ctx->
encoder);
120 const char *detail = vpx_codec_error_detail(&ctx->
encoder);
128 const struct vpx_codec_enc_cfg *cfg)
133 av_log(avctx, level,
"vpx_codec_enc_cfg\n");
134 av_log(avctx, level,
"generic settings\n"
135 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
136 " %*s{%u/%u}\n %*s%u\n %*s%d\n %*s%u\n",
137 width,
"g_usage:", cfg->g_usage,
138 width,
"g_threads:", cfg->g_threads,
139 width,
"g_profile:", cfg->g_profile,
140 width,
"g_w:", cfg->g_w,
141 width,
"g_h:", cfg->g_h,
142 width,
"g_timebase:", cfg->g_timebase.num, cfg->g_timebase.den,
143 width,
"g_error_resilient:", cfg->g_error_resilient,
144 width,
"g_pass:", cfg->g_pass,
145 width,
"g_lag_in_frames:", cfg->g_lag_in_frames);
146 av_log(avctx, level,
"rate control settings\n"
147 " %*s%u\n %*s%u\n %*s%u\n %*s%u\n"
148 " %*s%d\n %*s%p(%zu)\n %*s%u\n",
149 width,
"rc_dropframe_thresh:", cfg->rc_dropframe_thresh,
150 width,
"rc_resize_allowed:", cfg->rc_resize_allowed,
151 width,
"rc_resize_up_thresh:", cfg->rc_resize_up_thresh,
152 width,
"rc_resize_down_thresh:", cfg->rc_resize_down_thresh,
153 width,
"rc_end_usage:", cfg->rc_end_usage,
154 width,
"rc_twopass_stats_in:", cfg->rc_twopass_stats_in.buf, cfg->rc_twopass_stats_in.sz,
155 width,
"rc_target_bitrate:", cfg->rc_target_bitrate);
156 av_log(avctx, level,
"quantizer settings\n"
158 width,
"rc_min_quantizer:", cfg->rc_min_quantizer,
159 width,
"rc_max_quantizer:", cfg->rc_max_quantizer);
160 av_log(avctx, level,
"bitrate tolerance\n"
162 width,
"rc_undershoot_pct:", cfg->rc_undershoot_pct,
163 width,
"rc_overshoot_pct:", cfg->rc_overshoot_pct);
164 av_log(avctx, level,
"decoder buffer model\n"
165 " %*s%u\n %*s%u\n %*s%u\n",
166 width,
"rc_buf_sz:", cfg->rc_buf_sz,
167 width,
"rc_buf_initial_sz:", cfg->rc_buf_initial_sz,
168 width,
"rc_buf_optimal_sz:", cfg->rc_buf_optimal_sz);
169 av_log(avctx, level,
"2 pass rate control settings\n"
170 " %*s%u\n %*s%u\n %*s%u\n",
171 width,
"rc_2pass_vbr_bias_pct:", cfg->rc_2pass_vbr_bias_pct,
172 width,
"rc_2pass_vbr_minsection_pct:", cfg->rc_2pass_vbr_minsection_pct,
173 width,
"rc_2pass_vbr_maxsection_pct:", cfg->rc_2pass_vbr_maxsection_pct);
174 av_log(avctx, level,
"keyframing settings\n"
175 " %*s%d\n %*s%u\n %*s%u\n",
176 width,
"kf_mode:", cfg->kf_mode,
177 width,
"kf_min_dist:", cfg->kf_min_dist,
178 width,
"kf_max_dist:", cfg->kf_max_dist);
179 av_log(avctx, level,
"\n");
189 cx_frame->
next = NULL;
212 enum vp8e_enc_control_id
id,
int val)
222 res = vpx_codec_control(&ctx->
encoder,
id, val);
223 if (res != VPX_CODEC_OK) {
224 snprintf(buf,
sizeof(buf),
"Failed to set %s codec control",
229 return res == VPX_CODEC_OK ? 0 :
AVERROR(EINVAL);
236 vpx_codec_destroy(&ctx->
encoder);
247 const struct vpx_codec_iface *iface)
250 struct vpx_codec_enc_cfg enccfg;
251 struct vpx_codec_enc_cfg enccfg_alpha;
261 if ((res = vpx_codec_enc_config_default(iface, &enccfg, 0)) != VPX_CODEC_OK) {
263 vpx_codec_err_to_string(res));
275 enccfg.g_w = avctx->
width;
276 enccfg.g_h = avctx->
height;
283 enccfg.g_pass = VPX_RC_FIRST_PASS;
285 enccfg.g_pass = VPX_RC_LAST_PASS;
287 enccfg.g_pass = VPX_RC_ONE_PASS;
291 enccfg.rc_end_usage = VPX_CBR;
293 enccfg.rc_end_usage = VPX_CQ;
299 if (enccfg.rc_end_usage == VPX_CQ) {
300 enccfg.rc_target_bitrate = 1000000;
302 avctx->
bit_rate = enccfg.rc_target_bitrate * 1000;
304 "Neither bitrate nor constrained quality specified, using default bitrate of %dkbit/sec\n",
305 enccfg.rc_target_bitrate);
309 if (avctx->
qmin >= 0)
310 enccfg.rc_min_quantizer = avctx->
qmin;
312 enccfg.rc_max_quantizer = avctx->
qmax;
314 if (enccfg.rc_end_usage == VPX_CQ) {
315 if (ctx->
crf < enccfg.rc_min_quantizer || ctx->
crf > enccfg.rc_max_quantizer) {
317 "CQ level must be between minimum and maximum quantizer value (%d-%d)\n",
318 enccfg.rc_min_quantizer, enccfg.rc_max_quantizer);
328 enccfg.rc_2pass_vbr_minsection_pct =
331 enccfg.rc_2pass_vbr_maxsection_pct =
338 enccfg.rc_buf_initial_sz =
340 enccfg.rc_buf_optimal_sz = enccfg.rc_buf_sz * 5 / 6;
347 enccfg.kf_max_dist = avctx->
gop_size;
349 if (enccfg.g_pass == VPX_RC_FIRST_PASS)
350 enccfg.g_lag_in_frames = 0;
351 else if (enccfg.g_pass == VPX_RC_LAST_PASS) {
363 "Stat buffer alloc (%zu bytes) failed\n",
369 if (decode_size < 0) {
382 enccfg.g_profile = avctx->
profile;
388 res = vpx_codec_enc_init(&ctx->
encoder, iface, &enccfg, flags);
389 if (res != VPX_CODEC_OK) {
395 enccfg_alpha = enccfg;
396 res = vpx_codec_enc_init(&ctx->
encoder_alpha, iface, &enccfg_alpha, flags);
397 if (res != VPX_CODEC_OK) {
444 const struct vpx_codec_cx_pkt *
src,
445 const struct vpx_codec_cx_pkt *src_alpha,
448 dst->
pts = src->data.frame.pts;
449 dst->
duration = src->data.frame.duration;
450 dst->
flags = src->data.frame.flags;
451 dst->
sz = src->data.frame.sz;
452 dst->
buf = src->data.frame.buf;
455 if (!(dst->
flags & VPX_FRAME_IS_INVISIBLE)) {
463 memcpy(dst->
sse, ctx->
sse,
sizeof(dst->
sse));
470 dst->
buf_alpha = src_alpha->data.frame.buf;
471 dst->
sz_alpha = src_alpha->data.frame.sz;
494 coded_frame->
pts = cx_frame->
pts;
506 coded_frame->
error[0] = cx_frame->
sse[1];
507 coded_frame->
error[1] = cx_frame->
sse[2];
508 coded_frame->
error[2] = cx_frame->
sse[3];
509 coded_frame->
error[3] = 0;
510 for (i = 0; i < 4; ++i) {
519 if(side_data == NULL) {
545 const struct vpx_codec_cx_pkt *
pkt;
546 const struct vpx_codec_cx_pkt *pkt_alpha = NULL;
547 const void *iter = NULL;
548 const void *iter_alpha = NULL;
554 size =
storeframe(avctx, cx_frame, pkt_out, coded_frame);
563 while ((pkt = vpx_codec_get_cx_data(&ctx->
encoder, &iter)) &&
567 case VPX_CODEC_CX_FRAME_PKT:
574 cx_pktcpy(&cx_frame, pkt, pkt_alpha, ctx);
575 size =
storeframe(avctx, &cx_frame, pkt_out, coded_frame);
584 "Frame queue element alloc failed\n");
587 cx_pktcpy(cx_frame, pkt, pkt_alpha, ctx);
590 if (!cx_frame->
buf) {
592 "Data buffer alloc (%zu bytes) failed\n",
597 memcpy(cx_frame->
buf, pkt->data.frame.buf, pkt->data.frame.sz);
602 "Data buffer alloc (%zu bytes) failed\n",
607 memcpy(cx_frame->
buf_alpha, pkt_alpha->data.frame.buf, pkt_alpha->data.frame.sz);
612 case VPX_CODEC_STATS_PKT: {
615 stats->sz + pkt->data.twopass_stats.sz);
620 memcpy((
uint8_t*)stats->buf + stats->sz,
621 pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);
622 stats->sz += pkt->data.twopass_stats.sz;
625 case VPX_CODEC_PSNR_PKT:
627 ctx->
sse[0] = pkt->data.psnr.sse[0];
628 ctx->
sse[1] = pkt->data.psnr.sse[1];
629 ctx->
sse[2] = pkt->data.psnr.sse[2];
630 ctx->
sse[3] = pkt->data.psnr.sse[3];
633 case VPX_CODEC_CUSTOM_PKT:
646 struct vpx_image *rawimg = NULL;
647 struct vpx_image *rawimg_alpha = NULL;
648 int64_t timestamp = 0;
650 vpx_enc_frame_flags_t
flags = 0;
654 rawimg->planes[VPX_PLANE_Y] = frame->
data[0];
655 rawimg->planes[VPX_PLANE_U] = frame->
data[1];
656 rawimg->planes[VPX_PLANE_V] = frame->
data[2];
657 rawimg->stride[VPX_PLANE_Y] = frame->
linesize[0];
658 rawimg->stride[VPX_PLANE_U] = frame->
linesize[1];
659 rawimg->stride[VPX_PLANE_V] = frame->
linesize[2];
663 rawimg_alpha->planes[VPX_PLANE_Y] = frame->
data[3];
666 rawimg_alpha->planes[VPX_PLANE_U] = u_plane;
669 rawimg_alpha->planes[VPX_PLANE_V] = v_plane;
670 rawimg_alpha->stride[VPX_PLANE_Y] = frame->
linesize[0];
671 rawimg_alpha->stride[VPX_PLANE_U] = frame->
linesize[1];
672 rawimg_alpha->stride[VPX_PLANE_V] = frame->
linesize[2];
674 timestamp = frame->
pts;
676 flags |= VPX_EFLAG_FORCE_KF;
679 res = vpx_codec_encode(&ctx->
encoder, rawimg, timestamp,
681 if (res != VPX_CODEC_OK) {
687 res = vpx_codec_encode(&ctx->
encoder_alpha, rawimg_alpha, timestamp,
689 if (res != VPX_CODEC_OK) {
711 av_free(rawimg_alpha->planes[VPX_PLANE_U]);
712 av_free(rawimg_alpha->planes[VPX_PLANE_V]);
715 *got_packet = !!coded_size;
719 #define OFFSET(x) offsetof(VP8Context, x)
720 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
722 {
"cpu-used",
"Quality/Speed ratio modifier",
OFFSET(cpu_used),
AV_OPT_TYPE_INT, {.i64 = INT_MIN}, INT_MIN, INT_MAX,
VE},
723 {
"auto-alt-ref",
"Enable use of alternate reference "
725 {
"lag-in-frames",
"Number of frames to look ahead for "
727 {
"arnr-maxframes",
"altref noise reduction max frame count",
OFFSET(arnr_max_frames),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX,
VE},
728 {
"arnr-strength",
"altref noise reduction filter strength",
OFFSET(arnr_strength),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX,
VE},
729 {
"arnr-type",
"altref noise reduction filter type",
OFFSET(arnr_type),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX,
VE,
"arnr_type"},
733 {
"deadline",
"Time to spend encoding, in microseconds.",
OFFSET(deadline),
AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX,
VE,
"quality"},
737 {
"error-resilient",
"Error resilience configuration",
OFFSET(error_resilient),
AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX,
VE,
"er"},
738 {
"max-intra-rate",
"Maximum I-frame bitrate (pct) 0=unlimited",
OFFSET(max_intra_rate),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX,
VE},
739 #ifdef VPX_ERROR_RESILIENT_DEFAULT
740 {
"default",
"Improve resiliency against losses of whole frames", 0,
AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_DEFAULT}, 0, 0,
VE,
"er"},
741 {
"partitions",
"The frame partitions are independently decodable "
742 "by the bool decoder, meaning that partitions can be decoded even "
743 "though earlier partitions have been lost. Note that intra predicition"
744 " is still done over the partition boundary.", 0,
AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_PARTITIONS}, 0, 0,
VE,
"er"},
747 {
"quality",
"", offsetof(
VP8Context, deadline),
AV_OPT_TYPE_INT, {.i64 = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX,
VE,
"quality"},
748 {
"vp8flags",
"", offsetof(
VP8Context,
flags),
FF_OPT_TYPE_FLAGS, {.i64 = 0}, 0, UINT_MAX,
VE,
"flags"},
751 {
"arnr_max_frames",
"altref noise reduction max frame count", offsetof(
VP8Context, arnr_max_frames),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, 15,
VE},
752 {
"arnr_strength",
"altref noise reduction filter strength", offsetof(
VP8Context, arnr_strength),
AV_OPT_TYPE_INT, {.i64 = 3}, 0, 6,
VE},
754 {
"rc_lookahead",
"Number of frames to look ahead for alternate reference frame selection", offsetof(
VP8Context, lag_in_frames),
AV_OPT_TYPE_INT, {.i64 = 25}, 0, 25,
VE},
763 {
"keyint_min",
"-1" },
767 #if CONFIG_LIBVPX_VP8_ENCODER
770 return vpx_init(avctx, &vpx_codec_vp8_cx_algo);
773 static const AVClass class_vp8 = {
780 AVCodec ff_libvpx_vp8_encoder = {
791 .priv_class = &class_vp8,
796 #if CONFIG_LIBVPX_VP9_ENCODER
799 return vpx_init(avctx, &vpx_codec_vp9_cx_algo);
802 static const AVClass class_vp9 = {
809 AVCodec ff_libvpx_vp9_encoder = {
810 .
name =
"libvpx-vp9",
820 .priv_class = &class_vp9,
struct vpx_image rawimg_alpha
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and/or allocate data.
const char const char void * val
void av_free_packet(AVPacket *pkt)
Free a packet.
This structure describes decoded (raw) audio or video data.
struct vpx_codec_ctx encoder
#define CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding) av_const
Rescale a 64-bit integer with specified rounding.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define LIBAVUTIL_VERSION_INT
#define CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
static av_cold int init(AVCodecContext *avctx)
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
AVFrame * avcodec_alloc_frame(void)
Allocate an AVFrame and set its fields to default values.
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
char * av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size)
Encode data to base64 and null-terminate.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
size_t sz
length of compressed data
static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride)
struct vpx_codec_ctx encoder_alpha
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
void av_freep(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
#define VP8F_AUTO_ALT_REF
Enable automatic alternate reference frame generation.
#define CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
const char * av_default_item_name(void *ctx)
Return the context name.
static av_cold int codecctl_int(AVCodecContext *avctx, enum vp8e_enc_control_id id, int val)
int64_t pts
time stamp to show frame (in timebase units)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
static void coded_frame_add(void *list, struct FrameListData *cx_frame)
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
const char * name
Name of the codec implementation.
int mb_threshold
Macroblock threshold below which the user specified macroblock types will be used.
#define AV_LOG_VERBOSE
Detailed information.
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
const OptionDef options[]
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
#define CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
int frame_skip_threshold
frame skip threshold
int qmax
maximum quantizer
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Round to nearest and halfway cases away from zero.
int rc_max_rate
maximum bitrate
static av_always_inline av_const double round(double x)
Libavcodec external API header.
AVPixelFormat
Pixel format.
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
int flags
A combination of AV_PKT_FLAG values.
int rc_buffer_size
decoder bitstream buffer size
static void cx_pktcpy(struct FrameListData *dst, const struct vpx_codec_cx_pkt *src, const struct vpx_codec_cx_pkt *src_alpha, VP8Context *ctx)
static av_cold void dump_enc_cfg(AVCodecContext *avctx, const struct vpx_codec_enc_cfg *cfg)
int bit_rate
the average bitrate
enum AVPictureType pict_type
Picture type of the frame.
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
int width
picture width / height.
void * av_malloc(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
#define CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
uint64_t error[AV_NUM_DATA_POINTERS]
error
static av_cold int vp8_free(AVCodecContext *avctx)
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
#define FF_PROFILE_UNKNOWN
static av_cold void log_encoder_error(AVCodecContext *avctx, const char *desc)
char * stats_out
pass1 encoding statistics output buffer
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
struct FrameListData * next
#define VP8F_ERROR_RESILIENT
Enable measures appropriate for streaming over lossy links.
static av_cold int vpx_init(AVCodecContext *avctx, const struct vpx_codec_iface *iface)
int flags
VP8 specific flags, see VP8F_* below.
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
static const AVCodecDefault defaults[]
#define AV_LOG_INFO
Standard information.
main external API structure.
static void close(AVCodecParserContext *s)
int qmin
minimum quantizer
void * av_realloc_f(void *ptr, size_t nelem, size_t elsize)
Allocate or reallocate a block of memory.
static int storeframe(AVCodecContext *avctx, struct FrameListData *cx_frame, AVPacket *pkt, AVFrame *coded_frame)
Store coded frame information in format suitable for return from encode2().
Data found in BlockAdditional element of matroska container.
Describe the class of an AVClass context structure.
float rc_buffer_aggressivity
AVFrame * coded_frame
the picture in the bitstream
uint32_t flags
flags for this frame
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
uint64_t error[AV_NUM_DATA_POINTERS]
error
static av_cold void free_coded_frame(struct FrameListData *cx_frame)
float qcompress
amount of qscale change between easy & hard scenes (0.0-1.0)
static int vp8_encode(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
void * buf
compressed data buffer
int have_sse
true if we have pending sse[]
int noise_reduction
noise reduction strength
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
static const char *const ctlidstr[]
String mappings for enum vp8e_enc_control_id.
struct vpx_fixed_buf twopass_stats
common internal api header.
#define CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
static av_cold void free_frame_list(struct FrameListData *list)
int slices
Number of slices.
#define AVERROR_INVALIDDATA
Portion of struct vpx_codec_cx_pkt from vpx_encoder.h.
int key_frame
1 -> keyframe, 0-> not
unsigned long duration
duration to show frame (in timebase units)
int av_base64_decode(uint8_t *out, const char *in, int out_size)
Decode a base64-encoded string.
int have_sse
true if we have pending sse[]
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
static int queue_frames(AVCodecContext *avctx, AVPacket *pkt_out, AVFrame *coded_frame)
Queue multiple output frames from the encoder, returning the front-most.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int rc_min_rate
minimum bitrate
This structure stores compressed data.
struct FrameListData * coded_frame_list
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
int keyint_min
minimum GOP size