git.sesse.net Git - ffmpeg/blob - libavcodec/vaapi_encode_vp9.c

   1 /*
   2  * This file is part of FFmpeg.
   3  *
   4  * FFmpeg 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  * FFmpeg 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 FFmpeg; 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 #define VP9_MAX_QUANT 255
  33
  34
  35 typedef struct VAAPIEncodeVP9Picture {
  36     int slot;
  37 } VAAPIEncodeVP9Picture;
  38
  39 typedef struct VAAPIEncodeVP9Context {
  40     VAAPIEncodeContext common;
  41
  42     // User options.
  43     int loop_filter_level;
  44     int loop_filter_sharpness;
  45
  46     // Derived settings.
  47     int q_idx_idr;
  48     int q_idx_p;
  49     int q_idx_b;
  50 } VAAPIEncodeVP9Context;
  51
  52
  53 static int vaapi_encode_vp9_init_sequence_params(AVCodecContext *avctx)
  54 {
  55     VAAPIEncodeContext               *ctx = avctx->priv_data;
  56     VAEncSequenceParameterBufferVP9 *vseq = ctx->codec_sequence_params;
  57     VAEncPictureParameterBufferVP9  *vpic = ctx->codec_picture_params;
  58
  59     vseq->max_frame_width  = avctx->width;
  60     vseq->max_frame_height = avctx->height;
  61
  62     vseq->kf_auto = 0;
  63
  64     if (!(ctx->va_rc_mode & VA_RC_CQP)) {
  65         vseq->bits_per_second = ctx->va_bit_rate;
  66         vseq->intra_period    = ctx->gop_size;
  67     }
  68
  69     vpic->frame_width_src  = avctx->width;
  70     vpic->frame_height_src = avctx->height;
  71     vpic->frame_width_dst  = avctx->width;
  72     vpic->frame_height_dst = avctx->height;
  73
  74     return 0;
  75 }
  76
  77 static int vaapi_encode_vp9_init_picture_params(AVCodecContext *avctx,
  78                                                 VAAPIEncodePicture *pic)
  79 {
  80     VAAPIEncodeContext              *ctx = avctx->priv_data;
  81     VAAPIEncodeVP9Context          *priv = avctx->priv_data;
  82     VAAPIEncodeVP9Picture          *hpic = pic->priv_data;
  83     VAEncPictureParameterBufferVP9 *vpic = pic->codec_picture_params;
  84     int i;
  85
  86     vpic->reconstructed_frame = pic->recon_surface;
  87     vpic->coded_buf = pic->output_buffer;
  88
  89     switch (pic->type) {
  90     case PICTURE_TYPE_IDR:
  91         av_assert0(pic->nb_refs == 0);
  92         vpic->ref_flags.bits.force_kf = 1;
  93         vpic->refresh_frame_flags = 0xff;
  94         hpic->slot = 0;
  95         break;
  96     case PICTURE_TYPE_P:
  97         av_assert0(pic->nb_refs == 1);
  98         {
  99             VAAPIEncodeVP9Picture *href = pic->refs[0]->priv_data;
 100             av_assert0(href->slot == 0 || href->slot == 1);
 101
 102             if (ctx->max_b_depth > 0) {
 103                 hpic->slot = !href->slot;
 104                 vpic->refresh_frame_flags = 1 << hpic->slot | 0xfc;
 105             } else {
 106                 hpic->slot = 0;
 107                 vpic->refresh_frame_flags = 0xff;
 108             }
 109             vpic->ref_flags.bits.ref_frame_ctrl_l0  = 1;
 110             vpic->ref_flags.bits.ref_last_idx       = href->slot;
 111             vpic->ref_flags.bits.ref_last_sign_bias = 1;
 112         }
 113         break;
 114     case PICTURE_TYPE_B:
 115         av_assert0(pic->nb_refs == 2);
 116         {
 117             VAAPIEncodeVP9Picture *href0 = pic->refs[0]->priv_data,
 118                                   *href1 = pic->refs[1]->priv_data;
 119             av_assert0(href0->slot < pic->b_depth + 1 &&
 120                        href1->slot < pic->b_depth + 1);
 121
 122             if (pic->b_depth == ctx->max_b_depth) {
 123                 // Unreferenced frame.
 124                 vpic->refresh_frame_flags = 0x00;
 125                 hpic->slot = 8;
 126             } else {
 127                 vpic->refresh_frame_flags = 0xfe << pic->b_depth & 0xff;
 128                 hpic->slot = 1 + pic->b_depth;
 129             }
 130             vpic->ref_flags.bits.ref_frame_ctrl_l0  = 1;
 131             vpic->ref_flags.bits.ref_frame_ctrl_l1  = 2;
 132             vpic->ref_flags.bits.ref_last_idx       = href0->slot;
 133             vpic->ref_flags.bits.ref_last_sign_bias = 1;
 134             vpic->ref_flags.bits.ref_gf_idx         = href1->slot;
 135             vpic->ref_flags.bits.ref_gf_sign_bias   = 0;
 136         }
 137         break;
 138     default:
 139         av_assert0(0 && "invalid picture type");
 140     }
 141     if (vpic->refresh_frame_flags == 0x00) {
 142         av_log(avctx, AV_LOG_DEBUG, "Pic %"PRId64" not stored.\n",
 143                pic->display_order);
 144     } else {
 145         av_log(avctx, AV_LOG_DEBUG, "Pic %"PRId64" stored in slot %d.\n",
 146                pic->display_order, hpic->slot);
 147     }
 148
 149     for (i = 0; i < FF_ARRAY_ELEMS(vpic->reference_frames); i++)
 150         vpic->reference_frames[i] = VA_INVALID_SURFACE;
 151
 152     for (i = 0; i < pic->nb_refs; i++) {
 153         VAAPIEncodePicture *ref_pic = pic->refs[i];
 154         int slot;
 155         slot = ((VAAPIEncodeVP9Picture*)ref_pic->priv_data)->slot;
 156         av_assert0(vpic->reference_frames[slot] == VA_INVALID_SURFACE);
 157         vpic->reference_frames[slot] = ref_pic->recon_surface;
 158     }
 159
 160     vpic->pic_flags.bits.frame_type = (pic->type != PICTURE_TYPE_IDR);
 161     vpic->pic_flags.bits.show_frame = pic->display_order <= pic->encode_order;
 162
 163     if (pic->type == PICTURE_TYPE_IDR)
 164         vpic->luma_ac_qindex     = priv->q_idx_idr;
 165     else if (pic->type == PICTURE_TYPE_P)
 166         vpic->luma_ac_qindex     = priv->q_idx_p;
 167     else
 168         vpic->luma_ac_qindex     = priv->q_idx_b;
 169     vpic->luma_dc_qindex_delta   = 0;
 170     vpic->chroma_ac_qindex_delta = 0;
 171     vpic->chroma_dc_qindex_delta = 0;
 172
 173     vpic->filter_level    = priv->loop_filter_level;
 174     vpic->sharpness_level = priv->loop_filter_sharpness;
 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 = avctx->priv_data;
 183
 184     if (ctx->rc_mode->quality) {
 185         priv->q_idx_p = av_clip(ctx->rc_quality, 0, VP9_MAX_QUANT);
 186         if (avctx->i_quant_factor > 0.0)
 187             priv->q_idx_idr =
 188                 av_clip((avctx->i_quant_factor * priv->q_idx_p  +
 189                          avctx->i_quant_offset) + 0.5,
 190                         0, VP9_MAX_QUANT);
 191         else
 192             priv->q_idx_idr = priv->q_idx_p;
 193         if (avctx->b_quant_factor > 0.0)
 194             priv->q_idx_b =
 195                 av_clip((avctx->b_quant_factor * priv->q_idx_p  +
 196                          avctx->b_quant_offset) + 0.5,
 197                         0, VP9_MAX_QUANT);
 198         else
 199             priv->q_idx_b = priv->q_idx_p;
 200     } else {
 201         // Arbitrary value.
 202         priv->q_idx_idr = priv->q_idx_p = priv->q_idx_b = 100;
 203     }
 204
 205     ctx->roi_quant_range = VP9_MAX_QUANT;
 206
 207     return 0;
 208 }
 209
 210 static const VAAPIEncodeProfile vaapi_encode_vp9_profiles[] = {
 211     { FF_PROFILE_VP9_0,  8, 3, 1, 1, VAProfileVP9Profile0 },
 212     { FF_PROFILE_VP9_2, 10, 3, 1, 1, VAProfileVP9Profile2 },
 213     { FF_PROFILE_UNKNOWN }
 214 };
 215
 216 static const VAAPIEncodeType vaapi_encode_type_vp9 = {
 217     .profiles              = vaapi_encode_vp9_profiles,
 218
 219     .flags                 = FLAG_B_PICTURES |
 220                              FLAG_B_PICTURE_REFERENCES,
 221
 222     .default_quality       = 100,
 223
 224     .picture_priv_data_size = sizeof(VAAPIEncodeVP9Picture),
 225
 226     .configure             = &vaapi_encode_vp9_configure,
 227
 228     .sequence_params_size  = sizeof(VAEncSequenceParameterBufferVP9),
 229     .init_sequence_params  = &vaapi_encode_vp9_init_sequence_params,
 230
 231     .picture_params_size   = sizeof(VAEncPictureParameterBufferVP9),
 232     .init_picture_params   = &vaapi_encode_vp9_init_picture_params,
 233 };
 234
 235 static av_cold int vaapi_encode_vp9_init(AVCodecContext *avctx)
 236 {
 237     VAAPIEncodeContext *ctx = avctx->priv_data;
 238
 239     ctx->codec = &vaapi_encode_type_vp9;
 240
 241     // No packed headers are currently desired.  They could be written,
 242     // but there isn't any reason to do so - the one usable driver (i965)
 243     // can write its own headers and there is no metadata to include.
 244     ctx->desired_packed_headers = 0;
 245
 246     // Surfaces must be aligned to superblock boundaries.
 247     ctx->surface_width  = FFALIGN(avctx->width,  64);
 248     ctx->surface_height = FFALIGN(avctx->height, 64);
 249
 250     return ff_vaapi_encode_init(avctx);
 251 }
 252
 253 #define OFFSET(x) offsetof(VAAPIEncodeVP9Context, x)
 254 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
 255 static const AVOption vaapi_encode_vp9_options[] = {
 256     VAAPI_ENCODE_COMMON_OPTIONS,
 257     VAAPI_ENCODE_RC_OPTIONS,
 258
 259     { "loop_filter_level", "Loop filter level",
 260       OFFSET(loop_filter_level), AV_OPT_TYPE_INT, { .i64 = 16 }, 0, 63, FLAGS },
 261     { "loop_filter_sharpness", "Loop filter sharpness",
 262       OFFSET(loop_filter_sharpness), AV_OPT_TYPE_INT, { .i64 = 4 }, 0, 15, FLAGS },
 263     { NULL },
 264 };
 265
 266 static const AVCodecDefault vaapi_encode_vp9_defaults[] = {
 267     { "b",              "0"   },
 268     { "bf",             "0"   },
 269     { "g",              "250" },
 270     { "qmin",           "-1"  },
 271     { "qmax",           "-1"  },
 272     { NULL },
 273 };
 274
 275 static const AVClass vaapi_encode_vp9_class = {
 276     .class_name = "vp9_vaapi",
 277     .item_name  = av_default_item_name,
 278     .option     = vaapi_encode_vp9_options,
 279     .version    = LIBAVUTIL_VERSION_INT,
 280 };
 281
 282 AVCodec ff_vp9_vaapi_encoder = {
 283     .name           = "vp9_vaapi",
 284     .long_name      = NULL_IF_CONFIG_SMALL("VP9 (VAAPI)"),
 285     .type           = AVMEDIA_TYPE_VIDEO,
 286     .id             = AV_CODEC_ID_VP9,
 287     .priv_data_size = sizeof(VAAPIEncodeVP9Context),
 288     .init           = &vaapi_encode_vp9_init,
 289     .send_frame     = &ff_vaapi_encode_send_frame,
 290     .receive_packet = &ff_vaapi_encode_receive_packet,
 291     .close          = &ff_vaapi_encode_close,
 292     .priv_class     = &vaapi_encode_vp9_class,
 293     .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HARDWARE,
 294     .defaults       = vaapi_encode_vp9_defaults,
 295     .pix_fmts = (const enum AVPixelFormat[]) {
 296         AV_PIX_FMT_VAAPI,
 297         AV_PIX_FMT_NONE,
 298     },
 299     .wrapper_name   = "vaapi",
 300 };