Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

vaapi_encode: Add VP9 support

Browse Source
pull/272/head
Mark Thompson 8 years ago
parent 34e051d168
commit 0fd91e4bfc
5 changed files with 317 additions and 1 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 3
      configure
  2. 1
      libavcodec/Makefile
  3. 1
      libavcodec/allcodecs.c
  4. 311
      libavcodec/vaapi_encode_vp9.c
  5. 2
      libavcodec/version.h

3
configure vendored
Unescape View File

@ -2273,6 +2273,8 @@ vp8_qsv_decoder_deps="libmfx"
vp8_qsv_decoder_select="qsvdec vp8_qsv_hwaccel vp8_parser"
vp8_vaapi_encoder_deps="VAEncPictureParameterBufferVP8"
vp8_vaapi_encoder_select="vaapi_encode"
vp9_vaapi_encoder_deps="VAEncPictureParameterBufferVP9"
vp9_vaapi_encoder_select="vaapi_encode"
nvenc_h264_encoder_select="h264_nvenc_encoder"
nvenc_hevc_encoder_select="hevc_nvenc_encoder"
@ -4666,6 +4668,7 @@ check_type "va/va.h va/va_enc_hevc.h" "VAEncPictureParameterBufferHEVC"
check_type "va/va.h va/va_enc_jpeg.h" "VAEncPictureParameterBufferJPEG"
check_type "va/va.h va/va_enc_mpeg2.h" "VAEncPictureParameterBufferMPEG2"
check_type "va/va.h va/va_enc_vp8.h" "VAEncPictureParameterBufferVP8"
check_type "va/va.h va/va_enc_vp9.h" "VAEncPictureParameterBufferVP9"
check_type "vdpau/vdpau.h" "VdpPictureInfoHEVC"

1
libavcodec/Makefile
Unescape View File

@ -485,6 +485,7 @@ OBJS-$(CONFIG_VP8_QSV_DECODER) += qsvdec_other.o
OBJS-$(CONFIG_VP8_VAAPI_ENCODER) += vaapi_encode_vp8.o
OBJS-$(CONFIG_VP9_DECODER) += vp9.o vp9data.o vp9dsp.o \
vp9block.o vp9prob.o vp9mvs.o vp56rac.o
OBJS-$(CONFIG_VP9_VAAPI_ENCODER) += vaapi_encode_vp9.o
OBJS-$(CONFIG_VQA_DECODER) += vqavideo.o
OBJS-$(CONFIG_WAVPACK_DECODER) += wavpack.o
OBJS-$(CONFIG_WEBP_DECODER) += webp.o

1
libavcodec/allcodecs.c
Unescape View File

@ -511,6 +511,7 @@ void avcodec_register_all(void)
REGISTER_ENCODER(NVENC_HEVC, nvenc_hevc);
#endif
REGISTER_ENCODER(VP8_VAAPI, vp8_vaapi);
REGISTER_ENCODER(VP9_VAAPI, vp9_vaapi);
/* parsers */
REGISTER_PARSER(AAC, aac);

311
libavcodec/vaapi_encode_vp9.c
Unescape View File

@ -0,0 +1,311 @@
/*
* This file is part of Libav.
*
* Libav is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* Libav is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with Libav; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <va/va.h>
#include <va/va_enc_vp9.h>
#include "libavutil/avassert.h"
#include "libavutil/common.h"
#include "libavutil/internal.h"
#include "libavutil/opt.h"
#include "libavutil/pixfmt.h"
#include "avcodec.h"
#include "internal.h"
#include "vaapi_encode.h"
typedef struct VAAPIEncodeVP9Context {
int q_idx_idr;
int q_idx_p;
int q_idx_b;
// Reference direction for B-like frames:
// 0 - most recent P/IDR frame is last.
// 1 - most recent P frame is golden.
int last_ref_dir;
} VAAPIEncodeVP9Context;
typedef struct VAAPIEncodeVP9Options {
int loop_filter_level;
int loop_filter_sharpness;
} VAAPIEncodeVP9Options;
#define vseq_var(name) vseq->name, name
#define vseq_field(name) vseq->seq_fields.bits.name, name
#define vpic_var(name) vpic->name, name
#define vpic_field(name) vpic->pic_fields.bits.name, name
static int vaapi_encode_vp9_init_sequence_params(AVCodecContext *avctx)
{
VAAPIEncodeContext *ctx = avctx->priv_data;
VAEncSequenceParameterBufferVP9 *vseq = ctx->codec_sequence_params;
VAEncPictureParameterBufferVP9 *vpic = ctx->codec_picture_params;
vseq->max_frame_width = avctx->width;
vseq->max_frame_height = avctx->height;
vseq->kf_auto = 0;
if (!(ctx->va_rc_mode & VA_RC_CQP)) {
vseq->bits_per_second = avctx->bit_rate;
vseq->intra_period = avctx->gop_size;
}
vpic->frame_width_src = avctx->width;
vpic->frame_height_src = avctx->height;
vpic->frame_width_dst = avctx->width;
vpic->frame_height_dst = avctx->height;
return 0;
}
static int vaapi_encode_vp9_init_picture_params(AVCodecContext *avctx,
VAAPIEncodePicture *pic)
{
VAAPIEncodeContext *ctx = avctx->priv_data;
VAEncPictureParameterBufferVP9 *vpic = pic->codec_picture_params;
VAAPIEncodeVP9Context *priv = ctx->priv_data;
VAAPIEncodeVP9Options *opt = ctx->codec_options;
int i;
vpic->reconstructed_frame = pic->recon_surface;
vpic->coded_buf = pic->output_buffer;
switch (pic->type) {
case PICTURE_TYPE_IDR:
av_assert0(pic->nb_refs == 0);
vpic->ref_flags.bits.force_kf = 1;
vpic->refresh_frame_flags = 0x01;
priv->last_ref_dir = 0;
break;
case PICTURE_TYPE_P:
av_assert0(pic->nb_refs == 1);
if (avctx->max_b_frames > 0) {
if (priv->last_ref_dir) {
vpic->ref_flags.bits.ref_frame_ctrl_l0 = 2;
vpic->ref_flags.bits.ref_gf_idx = 1;
vpic->ref_flags.bits.ref_gf_sign_bias = 1;
vpic->refresh_frame_flags = 0x01;
} else {
vpic->ref_flags.bits.ref_frame_ctrl_l0 = 1;
vpic->ref_flags.bits.ref_last_idx = 0;
vpic->ref_flags.bits.ref_last_sign_bias = 1;
vpic->refresh_frame_flags = 0x02;
}
} else {
vpic->ref_flags.bits.ref_frame_ctrl_l0 = 1;
vpic->ref_flags.bits.ref_last_idx = 0;
vpic->ref_flags.bits.ref_last_sign_bias = 1;
vpic->refresh_frame_flags = 0x01;
}
break;
case PICTURE_TYPE_B:
av_assert0(pic->nb_refs == 2);
if (priv->last_ref_dir) {
vpic->ref_flags.bits.ref_frame_ctrl_l0 = 1;
vpic->ref_flags.bits.ref_frame_ctrl_l1 = 2;
vpic->ref_flags.bits.ref_last_idx = 0;
vpic->ref_flags.bits.ref_last_sign_bias = 1;
vpic->ref_flags.bits.ref_gf_idx = 1;
vpic->ref_flags.bits.ref_gf_sign_bias = 0;
} else {
vpic->ref_flags.bits.ref_frame_ctrl_l0 = 2;
vpic->ref_flags.bits.ref_frame_ctrl_l1 = 1;
vpic->ref_flags.bits.ref_last_idx = 0;
vpic->ref_flags.bits.ref_last_sign_bias = 0;
vpic->ref_flags.bits.ref_gf_idx = 1;
vpic->ref_flags.bits.ref_gf_sign_bias = 1;
}
vpic->refresh_frame_flags = 0x00;
break;
default:
av_assert0(0 && "invalid picture type");
}
for (i = 0; i < FF_ARRAY_ELEMS(vpic->reference_frames); i++)
vpic->reference_frames[i] = VA_INVALID_SURFACE;
if (pic->type == PICTURE_TYPE_P) {
av_assert0(pic->refs[0]);
vpic->reference_frames[priv->last_ref_dir] =
pic->refs[0]->recon_surface;
} else if (pic->type == PICTURE_TYPE_B) {
av_assert0(pic->refs[0] && pic->refs[1]);
vpic->reference_frames[!priv->last_ref_dir] =
pic->refs[0]->recon_surface;
vpic->reference_frames[priv->last_ref_dir] =
pic->refs[1]->recon_surface;
}
vpic->pic_flags.bits.frame_type = (pic->type != PICTURE_TYPE_IDR);
vpic->pic_flags.bits.show_frame = pic->display_order <= pic->encode_order;
if (pic->type == PICTURE_TYPE_IDR)
vpic->luma_ac_qindex = priv->q_idx_idr;
else if (pic->type == PICTURE_TYPE_P)
vpic->luma_ac_qindex = priv->q_idx_p;
else
vpic->luma_ac_qindex = priv->q_idx_b;
vpic->luma_dc_qindex_delta = 0;
vpic->chroma_ac_qindex_delta = 0;
vpic->chroma_dc_qindex_delta = 0;
vpic->filter_level = opt->loop_filter_level;
vpic->sharpness_level = opt->loop_filter_sharpness;
if (avctx->max_b_frames > 0 && pic->type == PICTURE_TYPE_P)
priv->last_ref_dir = !priv->last_ref_dir;
return 0;
}
static av_cold int vaapi_encode_vp9_configure(AVCodecContext *avctx)
{
VAAPIEncodeContext *ctx = avctx->priv_data;
VAAPIEncodeVP9Context *priv = ctx->priv_data;
priv->q_idx_p = av_clip(avctx->global_quality, 0, 255);
if (avctx->i_quant_factor > 0.0)
priv->q_idx_idr = av_clip((avctx->global_quality *
avctx->i_quant_factor +
avctx->i_quant_offset) + 0.5,
0, 255);
else
priv->q_idx_idr = priv->q_idx_p;
if (avctx->b_quant_factor > 0.0)
priv->q_idx_b = av_clip((avctx->global_quality *
avctx->b_quant_factor +
avctx->b_quant_offset) + 0.5,
0, 255);
else
priv->q_idx_b = priv->q_idx_p;
return 0;
}
static const VAAPIEncodeType vaapi_encode_type_vp9 = {
.configure = &vaapi_encode_vp9_configure,
.priv_data_size = sizeof(VAAPIEncodeVP9Context),
.sequence_params_size = sizeof(VAEncSequenceParameterBufferVP9),
.init_sequence_params = &vaapi_encode_vp9_init_sequence_params,
.picture_params_size = sizeof(VAEncPictureParameterBufferVP9),
.init_picture_params = &vaapi_encode_vp9_init_picture_params,
};
static av_cold int vaapi_encode_vp9_init(AVCodecContext *avctx)
{
VAAPIEncodeContext *ctx = avctx->priv_data;
ctx->codec = &vaapi_encode_type_vp9;
switch (avctx->profile) {
case FF_PROFILE_VP9_0:
case FF_PROFILE_UNKNOWN:
ctx->va_profile = VAProfileVP9Profile0;
ctx->va_rt_format = VA_RT_FORMAT_YUV420;
break;
case FF_PROFILE_VP9_1:
av_log(avctx, AV_LOG_ERROR, "VP9 profile 1 is not "
"supported.\n");
return AVERROR_PATCHWELCOME;
case FF_PROFILE_VP9_2:
ctx->va_profile = VAProfileVP9Profile2;
ctx->va_rt_format = VA_RT_FORMAT_YUV420_10BPP;
break;
case FF_PROFILE_VP9_3:
av_log(avctx, AV_LOG_ERROR, "VP9 profile 3 is not "
"supported.\n");
return AVERROR_PATCHWELCOME;
default:
av_log(avctx, AV_LOG_ERROR, "Unknown VP9 profile %d.\n",
avctx->profile);
return AVERROR(EINVAL);
}
ctx->va_entrypoint = VAEntrypointEncSlice;
if (avctx->flags & AV_CODEC_FLAG_QSCALE) {
ctx->va_rc_mode = VA_RC_CQP;
} else if (avctx->bit_rate > 0) {
if (avctx->bit_rate == avctx->rc_max_rate)
ctx->va_rc_mode = VA_RC_CBR;
else
ctx->va_rc_mode = VA_RC_VBR;
} else {
ctx->va_rc_mode = VA_RC_CQP;
}
// Packed headers are not currently supported.
ctx->va_packed_headers = 0;
// Surfaces must be aligned to superblock boundaries.
ctx->surface_width = FFALIGN(avctx->width, 64);
ctx->surface_height = FFALIGN(avctx->height, 64);
return ff_vaapi_encode_init(avctx);
}
#define OFFSET(x) (offsetof(VAAPIEncodeContext, codec_options_data) + \
offsetof(VAAPIEncodeVP9Options, x))
#define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
static const AVOption vaapi_encode_vp9_options[] = {
{ "loop_filter_level", "Loop filter level",
OFFSET(loop_filter_level), AV_OPT_TYPE_INT, { .i64 = 16 }, 0, 63, FLAGS },
{ "loop_filter_sharpness", "Loop filter sharpness",
OFFSET(loop_filter_sharpness), AV_OPT_TYPE_INT, { .i64 = 4 }, 0, 15, FLAGS },
{ NULL },
};
static const AVCodecDefault vaapi_encode_vp9_defaults[] = {
{ "profile", "0" },
{ "b", "0" },
{ "bf", "0" },
{ "g", "250" },
{ "global_quality", "100" },
{ NULL },
};
static const AVClass vaapi_encode_vp9_class = {
.class_name = "vp9_vaapi",
.item_name = av_default_item_name,
.option = vaapi_encode_vp9_options,
.version = LIBAVUTIL_VERSION_INT,
};
AVCodec ff_vp9_vaapi_encoder = {
.name = "vp9_vaapi",
.long_name = NULL_IF_CONFIG_SMALL("VP9 (VAAPI)"),
.type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_VP9,
.priv_data_size = (sizeof(VAAPIEncodeContext) +
sizeof(VAAPIEncodeVP9Options)),
.init = &vaapi_encode_vp9_init,
.encode2 = &ff_vaapi_encode2,
.close = &ff_vaapi_encode_close,
.priv_class = &vaapi_encode_vp9_class,
.capabilities = AV_CODEC_CAP_DELAY,
.defaults = vaapi_encode_vp9_defaults,
.pix_fmts = (const enum AVPixelFormat[]) {
AV_PIX_FMT_VAAPI,
AV_PIX_FMT_NONE,
},
};

2
libavcodec/version.h
Unescape View File

@ -28,7 +28,7 @@
#include "libavutil/version.h"
#define LIBAVCODEC_VERSION_MAJOR 58
#define LIBAVCODEC_VERSION_MINOR 0
#define LIBAVCODEC_VERSION_MINOR 1
#define LIBAVCODEC_VERSION_MICRO 0
#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \

Write Preview
Loading…
Cancel
Save