vaapi_encode: Add VP9 support
[ffmpeg.git] / libavcodec / vaapi_encode_vp9.c
1 /*
2  * This file is part of Libav.
3  *
4  * Libav is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * Libav is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with Libav; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18
19 #include <va/va.h>
20 #include <va/va_enc_vp9.h>
21
22 #include "libavutil/avassert.h"
23 #include "libavutil/common.h"
24 #include "libavutil/internal.h"
25 #include "libavutil/opt.h"
26 #include "libavutil/pixfmt.h"
27
28 #include "avcodec.h"
29 #include "internal.h"
30 #include "vaapi_encode.h"
31
32
33 typedef struct VAAPIEncodeVP9Context {
34     int q_idx_idr;
35     int q_idx_p;
36     int q_idx_b;
37
38     // Reference direction for B-like frames:
39     // 0 - most recent P/IDR frame is last.
40     // 1 - most recent P frame is golden.
41     int last_ref_dir;
42 } VAAPIEncodeVP9Context;
43
44 typedef struct VAAPIEncodeVP9Options {
45     int loop_filter_level;
46     int loop_filter_sharpness;
47 } VAAPIEncodeVP9Options;
48
49
50 #define vseq_var(name)     vseq->name, name
51 #define vseq_field(name)   vseq->seq_fields.bits.name, name
52 #define vpic_var(name)     vpic->name, name
53 #define vpic_field(name)   vpic->pic_fields.bits.name, name
54
55
56 static int vaapi_encode_vp9_init_sequence_params(AVCodecContext *avctx)
57 {
58     VAAPIEncodeContext               *ctx = avctx->priv_data;
59     VAEncSequenceParameterBufferVP9 *vseq = ctx->codec_sequence_params;
60     VAEncPictureParameterBufferVP9  *vpic = ctx->codec_picture_params;
61
62     vseq->max_frame_width  = avctx->width;
63     vseq->max_frame_height = avctx->height;
64
65     vseq->kf_auto = 0;
66
67     if (!(ctx->va_rc_mode & VA_RC_CQP)) {
68         vseq->bits_per_second = avctx->bit_rate;
69         vseq->intra_period    = avctx->gop_size;
70     }
71
72     vpic->frame_width_src  = avctx->width;
73     vpic->frame_height_src = avctx->height;
74     vpic->frame_width_dst  = avctx->width;
75     vpic->frame_height_dst = avctx->height;
76
77     return 0;
78 }
79
80 static int vaapi_encode_vp9_init_picture_params(AVCodecContext *avctx,
81                                                 VAAPIEncodePicture *pic)
82 {
83     VAAPIEncodeContext              *ctx = avctx->priv_data;
84     VAEncPictureParameterBufferVP9 *vpic = pic->codec_picture_params;
85     VAAPIEncodeVP9Context          *priv = ctx->priv_data;
86     VAAPIEncodeVP9Options           *opt = ctx->codec_options;
87     int i;
88
89     vpic->reconstructed_frame = pic->recon_surface;
90     vpic->coded_buf = pic->output_buffer;
91
92     switch (pic->type) {
93     case PICTURE_TYPE_IDR:
94         av_assert0(pic->nb_refs == 0);
95         vpic->ref_flags.bits.force_kf = 1;
96         vpic->refresh_frame_flags = 0x01;
97         priv->last_ref_dir = 0;
98         break;
99     case PICTURE_TYPE_P:
100         av_assert0(pic->nb_refs == 1);
101         if (avctx->max_b_frames > 0) {
102             if (priv->last_ref_dir) {
103                 vpic->ref_flags.bits.ref_frame_ctrl_l0  = 2;
104                 vpic->ref_flags.bits.ref_gf_idx         = 1;
105                 vpic->ref_flags.bits.ref_gf_sign_bias   = 1;
106                 vpic->refresh_frame_flags = 0x01;
107             } else {
108                 vpic->ref_flags.bits.ref_frame_ctrl_l0  = 1;
109                 vpic->ref_flags.bits.ref_last_idx       = 0;
110                 vpic->ref_flags.bits.ref_last_sign_bias = 1;
111                 vpic->refresh_frame_flags = 0x02;
112             }
113         } else {
114             vpic->ref_flags.bits.ref_frame_ctrl_l0  = 1;
115             vpic->ref_flags.bits.ref_last_idx       = 0;
116             vpic->ref_flags.bits.ref_last_sign_bias = 1;
117             vpic->refresh_frame_flags = 0x01;
118         }
119         break;
120     case PICTURE_TYPE_B:
121         av_assert0(pic->nb_refs == 2);
122         if (priv->last_ref_dir) {
123             vpic->ref_flags.bits.ref_frame_ctrl_l0  = 1;
124             vpic->ref_flags.bits.ref_frame_ctrl_l1  = 2;
125             vpic->ref_flags.bits.ref_last_idx       = 0;
126             vpic->ref_flags.bits.ref_last_sign_bias = 1;
127             vpic->ref_flags.bits.ref_gf_idx         = 1;
128             vpic->ref_flags.bits.ref_gf_sign_bias   = 0;
129         } else {
130             vpic->ref_flags.bits.ref_frame_ctrl_l0  = 2;
131             vpic->ref_flags.bits.ref_frame_ctrl_l1  = 1;
132             vpic->ref_flags.bits.ref_last_idx       = 0;
133             vpic->ref_flags.bits.ref_last_sign_bias = 0;
134             vpic->ref_flags.bits.ref_gf_idx         = 1;
135             vpic->ref_flags.bits.ref_gf_sign_bias   = 1;
136         }
137         vpic->refresh_frame_flags = 0x00;
138         break;
139     default:
140         av_assert0(0 && "invalid picture type");
141     }
142
143     for (i = 0; i < FF_ARRAY_ELEMS(vpic->reference_frames); i++)
144         vpic->reference_frames[i] = VA_INVALID_SURFACE;
145     if (pic->type == PICTURE_TYPE_P) {
146         av_assert0(pic->refs[0]);
147         vpic->reference_frames[priv->last_ref_dir] =
148             pic->refs[0]->recon_surface;
149     } else if (pic->type == PICTURE_TYPE_B) {
150         av_assert0(pic->refs[0] && pic->refs[1]);
151         vpic->reference_frames[!priv->last_ref_dir] =
152             pic->refs[0]->recon_surface;
153         vpic->reference_frames[priv->last_ref_dir] =
154             pic->refs[1]->recon_surface;
155     }
156
157     vpic->pic_flags.bits.frame_type = (pic->type != PICTURE_TYPE_IDR);
158     vpic->pic_flags.bits.show_frame = pic->display_order <= pic->encode_order;
159
160     if (pic->type == PICTURE_TYPE_IDR)
161         vpic->luma_ac_qindex     = priv->q_idx_idr;
162     else if (pic->type == PICTURE_TYPE_P)
163         vpic->luma_ac_qindex     = priv->q_idx_p;
164     else
165         vpic->luma_ac_qindex     = priv->q_idx_b;
166     vpic->luma_dc_qindex_delta   = 0;
167     vpic->chroma_ac_qindex_delta = 0;
168     vpic->chroma_dc_qindex_delta = 0;
169
170     vpic->filter_level    = opt->loop_filter_level;
171     vpic->sharpness_level = opt->loop_filter_sharpness;
172
173     if (avctx->max_b_frames > 0 && pic->type == PICTURE_TYPE_P)
174         priv->last_ref_dir = !priv->last_ref_dir;
175
176     return 0;
177 }
178
179 static av_cold int vaapi_encode_vp9_configure(AVCodecContext *avctx)
180 {
181     VAAPIEncodeContext     *ctx = avctx->priv_data;
182     VAAPIEncodeVP9Context *priv = ctx->priv_data;
183
184     priv->q_idx_p = av_clip(avctx->global_quality, 0, 255);
185     if (avctx->i_quant_factor > 0.0)
186         priv->q_idx_idr = av_clip((avctx->global_quality *
187                                    avctx->i_quant_factor +
188                                    avctx->i_quant_offset) + 0.5,
189                                   0, 255);
190     else
191         priv->q_idx_idr = priv->q_idx_p;
192     if (avctx->b_quant_factor > 0.0)
193         priv->q_idx_b = av_clip((avctx->global_quality *
194                                  avctx->b_quant_factor +
195                                  avctx->b_quant_offset) + 0.5,
196                                 0, 255);
197     else
198         priv->q_idx_b = priv->q_idx_p;
199
200     return 0;
201 }
202
203 static const VAAPIEncodeType vaapi_encode_type_vp9 = {
204     .configure             = &vaapi_encode_vp9_configure,
205
206     .priv_data_size        = sizeof(VAAPIEncodeVP9Context),
207
208     .sequence_params_size  = sizeof(VAEncSequenceParameterBufferVP9),
209     .init_sequence_params  = &vaapi_encode_vp9_init_sequence_params,
210
211     .picture_params_size   = sizeof(VAEncPictureParameterBufferVP9),
212     .init_picture_params   = &vaapi_encode_vp9_init_picture_params,
213 };
214
215 static av_cold int vaapi_encode_vp9_init(AVCodecContext *avctx)
216 {
217     VAAPIEncodeContext *ctx = avctx->priv_data;
218
219     ctx->codec = &vaapi_encode_type_vp9;
220
221     switch (avctx->profile) {
222     case FF_PROFILE_VP9_0:
223     case FF_PROFILE_UNKNOWN:
224         ctx->va_profile = VAProfileVP9Profile0;
225         ctx->va_rt_format = VA_RT_FORMAT_YUV420;
226         break;
227     case FF_PROFILE_VP9_1:
228         av_log(avctx, AV_LOG_ERROR, "VP9 profile 1 is not "
229                "supported.\n");
230         return AVERROR_PATCHWELCOME;
231     case FF_PROFILE_VP9_2:
232         ctx->va_profile = VAProfileVP9Profile2;
233         ctx->va_rt_format = VA_RT_FORMAT_YUV420_10BPP;
234         break;
235     case FF_PROFILE_VP9_3:
236         av_log(avctx, AV_LOG_ERROR, "VP9 profile 3 is not "
237                "supported.\n");
238         return AVERROR_PATCHWELCOME;
239     default:
240         av_log(avctx, AV_LOG_ERROR, "Unknown VP9 profile %d.\n",
241                avctx->profile);
242         return AVERROR(EINVAL);
243     }
244     ctx->va_entrypoint = VAEntrypointEncSlice;
245
246     if (avctx->flags & AV_CODEC_FLAG_QSCALE) {
247         ctx->va_rc_mode = VA_RC_CQP;
248     } else if (avctx->bit_rate > 0) {
249         if (avctx->bit_rate == avctx->rc_max_rate)
250             ctx->va_rc_mode = VA_RC_CBR;
251         else
252             ctx->va_rc_mode = VA_RC_VBR;
253     } else {
254         ctx->va_rc_mode = VA_RC_CQP;
255     }
256
257     // Packed headers are not currently supported.
258     ctx->va_packed_headers = 0;
259
260     // Surfaces must be aligned to superblock boundaries.
261     ctx->surface_width  = FFALIGN(avctx->width,  64);
262     ctx->surface_height = FFALIGN(avctx->height, 64);
263
264     return ff_vaapi_encode_init(avctx);
265 }
266
267 #define OFFSET(x) (offsetof(VAAPIEncodeContext, codec_options_data) + \
268                    offsetof(VAAPIEncodeVP9Options, x))
269 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
270 static const AVOption vaapi_encode_vp9_options[] = {
271     { "loop_filter_level", "Loop filter level",
272       OFFSET(loop_filter_level), AV_OPT_TYPE_INT, { .i64 = 16 }, 0, 63, FLAGS },
273     { "loop_filter_sharpness", "Loop filter sharpness",
274       OFFSET(loop_filter_sharpness), AV_OPT_TYPE_INT, { .i64 = 4 }, 0, 15, FLAGS },
275     { NULL },
276 };
277
278 static const AVCodecDefault vaapi_encode_vp9_defaults[] = {
279     { "profile",        "0"   },
280     { "b",              "0"   },
281     { "bf",             "0"   },
282     { "g",              "250" },
283     { "global_quality", "100" },
284     { NULL },
285 };
286
287 static const AVClass vaapi_encode_vp9_class = {
288     .class_name = "vp9_vaapi",
289     .item_name  = av_default_item_name,
290     .option     = vaapi_encode_vp9_options,
291     .version    = LIBAVUTIL_VERSION_INT,
292 };
293
294 AVCodec ff_vp9_vaapi_encoder = {
295     .name           = "vp9_vaapi",
296     .long_name      = NULL_IF_CONFIG_SMALL("VP9 (VAAPI)"),
297     .type           = AVMEDIA_TYPE_VIDEO,
298     .id             = AV_CODEC_ID_VP9,
299     .priv_data_size = (sizeof(VAAPIEncodeContext) +
300                        sizeof(VAAPIEncodeVP9Options)),
301     .init           = &vaapi_encode_vp9_init,
302     .encode2        = &ff_vaapi_encode2,
303     .close          = &ff_vaapi_encode_close,
304     .priv_class     = &vaapi_encode_vp9_class,
305     .capabilities   = AV_CODEC_CAP_DELAY,
306     .defaults       = vaapi_encode_vp9_defaults,
307     .pix_fmts = (const enum AVPixelFormat[]) {
308         AV_PIX_FMT_VAAPI,
309         AV_PIX_FMT_NONE,
310     },
311 };