diff mbox series

[FFmpeg-devel,v4] avcodec: add av1 VAAPI decoder

Message ID 20201002142808.17751-1-fei.w.wang@intel.com
State Superseded
Headers show
Series [FFmpeg-devel,v4] avcodec: add av1 VAAPI decoder
Related show

Checks

Context Check Description
andriy/default pending
andriy/make success Make finished
andriy/make_fate success Make fate finished

Commit Message

Wang, Fei W Oct. 2, 2020, 2:28 p.m. UTC
Example cmdline:
ffmpeg -hwaccel vaapi -hwaccel_device /dev/dri/renderD128 -v verbose \
-c:v av1 -i input.ivf -pix_fmt yuv420p -vsync passthrough -f md5     \
-y out.md5

Signed-off-by: Fei Wang <fei.w.wang@intel.com>
---
 Changelog                 |   1 +
 configure                 |   3 +
 libavcodec/Makefile       |   1 +
 libavcodec/av1dec.c       |  18 ++-
 libavcodec/hwaccels.h     |   1 +
 libavcodec/vaapi_av1.c    | 274 ++++++++++++++++++++++++++++++++++++++
 libavcodec/vaapi_decode.c |   6 +
 libavcodec/version.h      |   2 +-
 8 files changed, 304 insertions(+), 2 deletions(-)
 create mode 100644 libavcodec/vaapi_av1.c

Comments

Mark Thompson Oct. 28, 2020, 9:17 p.m. UTC | #1
On 02/10/2020 15:28, Fei Wang wrote:
> Example cmdline:
> ffmpeg -hwaccel vaapi -hwaccel_device /dev/dri/renderD128 -v verbose \
> -c:v av1 -i input.ivf -pix_fmt yuv420p -vsync passthrough -f md5     \
> -y out.md5
> 
> Signed-off-by: Fei Wang <fei.w.wang@intel.com>
> ---
>   Changelog                 |   1 +
>   configure                 |   3 +
>   libavcodec/Makefile       |   1 +
>   libavcodec/av1dec.c       |  18 ++-
>   libavcodec/hwaccels.h     |   1 +
>   libavcodec/vaapi_av1.c    | 274 ++++++++++++++++++++++++++++++++++++++
>   libavcodec/vaapi_decode.c |   6 +
>   libavcodec/version.h      |   2 +-
>   8 files changed, 304 insertions(+), 2 deletions(-)
>   create mode 100644 libavcodec/vaapi_av1.c

I think this is ok, but I can't test it myself.  Can you rebase against the recent changes in av1dec and retest that it is still good?

A kindof-related question: how does the selection of reference frames for skip modes work?  VAAPI isn't being given the SkipModeFrame array, and it doesn't appear to have the order hints to be able to work out which frames it should be using itself.

Thanks,

- Mark
Wang, Fei W Oct. 29, 2020, 8:16 a.m. UTC | #2
> -----Original Message-----
> From: ffmpeg-devel <ffmpeg-devel-bounces@ffmpeg.org> On Behalf Of Mark
> Thompson
> Sent: Thursday, October 29, 2020 5:18 AM
> To: ffmpeg-devel@ffmpeg.org
> Subject: Re: [FFmpeg-devel] [PATCH v4] avcodec: add av1 VAAPI decoder
> 
> On 02/10/2020 15:28, Fei Wang wrote:
> > Example cmdline:
> > ffmpeg -hwaccel vaapi -hwaccel_device /dev/dri/renderD128 -v verbose \
> > -c:v av1 -i input.ivf -pix_fmt yuv420p -vsync passthrough -f md5     \
> > -y out.md5
> >
> > Signed-off-by: Fei Wang <fei.w.wang@intel.com>
> > ---
> >   Changelog                 |   1 +
> >   configure                 |   3 +
> >   libavcodec/Makefile       |   1 +
> >   libavcodec/av1dec.c       |  18 ++-
> >   libavcodec/hwaccels.h     |   1 +
> >   libavcodec/vaapi_av1.c    | 274
> ++++++++++++++++++++++++++++++++++++++
> >   libavcodec/vaapi_decode.c |   6 +
> >   libavcodec/version.h      |   2 +-
> >   8 files changed, 304 insertions(+), 2 deletions(-)
> >   create mode 100644 libavcodec/vaapi_av1.c
> 
> I think this is ok, but I can't test it myself.  Can you rebase against the recent
> changes in av1dec and retest that it is still good?

Rebased with patch v5, and test looks good to me. Thanks.

> 
> A kindof-related question: how does the selection of reference frames for skip
> modes work?  VAAPI isn't being given the SkipModeFrame array, and it doesn't
> appear to have the order hints to be able to work out which frames it should be
> using itself.

Actually in media-driver, it maintains a reference frames parameter list which is used
to record and update reference frame's info. And refHint can be got in this list, and
with current frame's OrderHint (set by order_hint in VADecPictureParameterBufferAV1),
then can work out SkipModeFrame array following spec.

The detail implementation in media-driver is:
https://github.com/intel/media-driver/blob/d934d6c48644227ab066d013a105335ad25ce2bc/media_driver/media_driver_next/agnostic/common/codec/hal/dec/av1/packet/decode_av1_picture_packet.cpp#L1470 

> 
> Thanks,
> 
> - Mark
> _______________________________________________
> ffmpeg-devel mailing list
> ffmpeg-devel@ffmpeg.org
> https://ffmpeg.org/mailman/listinfo/ffmpeg-devel
> 
> To unsubscribe, visit link above, or email ffmpeg-devel-request@ffmpeg.org
> with subject "unsubscribe".
diff mbox series

Patch

diff --git a/Changelog b/Changelog
index 358cbaaf94..6358c54c90 100644
--- a/Changelog
+++ b/Changelog
@@ -30,6 +30,7 @@  version <next>:
 - IPU decoder, parser and demuxer
 - Intel QSV-accelerated AV1 decoding
 - Argonaut Games Video decoder
+- AV1 VAAPI decoder
 
 
 version 4.3:
diff --git a/configure b/configure
index b8de64ccae..730c99774e 100755
--- a/configure
+++ b/configure
@@ -2918,6 +2918,8 @@  videotoolbox_hwaccel_deps="videotoolbox pthreads"
 videotoolbox_hwaccel_extralibs="-framework QuartzCore"
 xvmc_deps="X11_extensions_XvMClib_h"
 
+av1_vaapi_hwaccel_deps="vaapi VADecPictureParameterBufferAV1_bit_depth_idx"
+av1_vaapi_hwaccel_select="av1_decoder"
 h263_vaapi_hwaccel_deps="vaapi"
 h263_vaapi_hwaccel_select="h263_decoder"
 h263_videotoolbox_hwaccel_deps="videotoolbox"
@@ -6675,6 +6677,7 @@  if enabled vaapi; then
 
     check_type "va/va.h va/va_dec_hevc.h" "VAPictureParameterBufferHEVC"
     check_struct "va/va.h" "VADecPictureParameterBufferVP9" bit_depth
+    check_struct "va/va.h" "VADecPictureParameterBufferAV1" bit_depth_idx
     check_type   "va/va.h va/va_vpp.h" "VAProcFilterParameterBufferHDRToneMapping"
     check_struct "va/va.h va/va_vpp.h" "VAProcPipelineCaps" rotation_flags
     check_type "va/va.h va/va_enc_hevc.h" "VAEncPictureParameterBufferHEVC"
diff --git a/libavcodec/Makefile b/libavcodec/Makefile
index 816d87ba60..59c08714bb 100644
--- a/libavcodec/Makefile
+++ b/libavcodec/Makefile
@@ -909,6 +909,7 @@  OBJS-$(CONFIG_VAAPI)                      += vaapi_decode.o
 OBJS-$(CONFIG_VIDEOTOOLBOX)               += videotoolbox.o
 OBJS-$(CONFIG_VDPAU)                      += vdpau.o
 
+OBJS-$(CONFIG_AV1_VAAPI_HWACCEL)          += vaapi_av1.o
 OBJS-$(CONFIG_H263_VAAPI_HWACCEL)         += vaapi_mpeg4.o
 OBJS-$(CONFIG_H263_VIDEOTOOLBOX_HWACCEL)  += videotoolbox.o
 OBJS-$(CONFIG_H264_D3D11VA_HWACCEL)       += dxva2_h264.o
diff --git a/libavcodec/av1dec.c b/libavcodec/av1dec.c
index 07026b7aeb..1bee2ce5ad 100644
--- a/libavcodec/av1dec.c
+++ b/libavcodec/av1dec.c
@@ -254,7 +254,7 @@  static int get_pixel_format(AVCodecContext *avctx)
     uint8_t bit_depth;
     int ret;
     enum AVPixelFormat pix_fmt = AV_PIX_FMT_NONE;
-#define HWACCEL_MAX (0)
+#define HWACCEL_MAX (CONFIG_AV1_VAAPI_HWACCEL)
     enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;
 
     if (seq->seq_profile == 2 && seq->color_config.high_bitdepth)
@@ -315,6 +315,19 @@  static int get_pixel_format(AVCodecContext *avctx)
         return -1;
     s->pix_fmt = pix_fmt;
 
+    switch (s->pix_fmt) {
+    case AV_PIX_FMT_YUV420P:
+#if CONFIG_AV1_VAAPI_HWACCEL
+        *fmtp++ = AV_PIX_FMT_VAAPI;
+#endif
+        break;
+    case AV_PIX_FMT_YUV420P10:
+#if CONFIG_AV1_VAAPI_HWACCEL
+        *fmtp++ = AV_PIX_FMT_VAAPI;
+#endif
+        break;
+    }
+
     *fmtp++ = s->pix_fmt;
     *fmtp = AV_PIX_FMT_NONE;
 
@@ -874,6 +887,9 @@  AVCodec ff_av1_decoder = {
     .flush                 = av1_decode_flush,
     .profiles              = NULL_IF_CONFIG_SMALL(ff_av1_profiles),
     .hw_configs            = (const AVCodecHWConfigInternal * []) {
+#if CONFIG_AV1_VAAPI_HWACCEL
+        HWACCEL_VAAPI(av1),
+#endif
         NULL
     },
 };
diff --git a/libavcodec/hwaccels.h b/libavcodec/hwaccels.h
index 6109c89bd6..18e9079c55 100644
--- a/libavcodec/hwaccels.h
+++ b/libavcodec/hwaccels.h
@@ -21,6 +21,7 @@ 
 
 #include "avcodec.h"
 
+extern const AVHWAccel ff_av1_vaapi_hwaccel;
 extern const AVHWAccel ff_h263_vaapi_hwaccel;
 extern const AVHWAccel ff_h263_videotoolbox_hwaccel;
 extern const AVHWAccel ff_h264_d3d11va_hwaccel;
diff --git a/libavcodec/vaapi_av1.c b/libavcodec/vaapi_av1.c
new file mode 100644
index 0000000000..ed6bd0e82b
--- /dev/null
+++ b/libavcodec/vaapi_av1.c
@@ -0,0 +1,274 @@ 
+/*
+ * AV1 HW decode acceleration through VA API
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libavutil/pixdesc.h"
+#include "hwconfig.h"
+#include "vaapi_decode.h"
+#include "av1dec.h"
+
+static VASurfaceID vaapi_av1_surface_id(AV1Frame *vf)
+{
+    if (vf)
+        return ff_vaapi_get_surface_id(vf->tf.f);
+    else
+        return VA_INVALID_SURFACE;
+}
+
+static int8_t vaapi_av1_get_bit_depth_idx(AVCodecContext *avctx)
+{
+    AV1DecContext *s = avctx->priv_data;
+    const AV1RawSequenceHeader *seq = s->raw_seq;
+    int8_t bit_depth = 8;
+
+    if (seq->seq_profile == 2 && seq->color_config.high_bitdepth)
+        bit_depth = seq->color_config.twelve_bit ? 12 : 10;
+    else if (seq->seq_profile <= 2)
+        bit_depth = seq->color_config.high_bitdepth ? 10 : 8;
+    else {
+        av_log(avctx, AV_LOG_ERROR,
+               "Couldn't get bit depth from profile:%d.\n", seq->seq_profile);
+        return -1;
+    }
+    return bit_depth == 8 ? 0 : bit_depth == 10 ? 1 : 2;
+}
+
+static int vaapi_av1_start_frame(AVCodecContext *avctx,
+                                 av_unused const uint8_t *buffer,
+                                 av_unused uint32_t size)
+{
+    AV1DecContext *s = avctx->priv_data;
+    const AV1RawSequenceHeader *seq = s->raw_seq;
+    const AV1RawFrameHeader *frame_header = s->raw_frame_header;
+    VAAPIDecodePicture *pic = s->cur_frame.hwaccel_picture_private;
+    VADecPictureParameterBufferAV1 pic_param;
+    int8_t bit_depth_idx;
+    int err = 0;
+    uint8_t remap_lr_type[4] = {AV1_RESTORE_NONE, AV1_RESTORE_SWITCHABLE, AV1_RESTORE_WIENER, AV1_RESTORE_SGRPROJ};
+
+    pic->output_surface = vaapi_av1_surface_id(&s->cur_frame);
+
+    bit_depth_idx = vaapi_av1_get_bit_depth_idx(avctx);
+    if (bit_depth_idx < 0)
+        goto fail;
+
+    memset(&pic_param, 0, sizeof(VADecPictureParameterBufferAV1));
+    pic_param = (VADecPictureParameterBufferAV1) {
+        .profile                 = seq->seq_profile,
+        .order_hint_bits_minus_1 = seq->order_hint_bits_minus_1,
+        .bit_depth_idx           = bit_depth_idx,
+        .current_frame           = pic->output_surface,
+        .current_display_picture = pic->output_surface,
+        .frame_width_minus1      = frame_header->frame_width_minus_1,
+        .frame_height_minus1     = frame_header->frame_height_minus_1,
+        .primary_ref_frame       = frame_header->primary_ref_frame,
+        .order_hint              = frame_header->order_hint,
+        .tile_cols               = frame_header->tile_cols,
+        .tile_rows               = frame_header->tile_rows,
+        .context_update_tile_id  = frame_header->context_update_tile_id,
+        .interp_filter           = frame_header->interpolation_filter,
+        .filter_level[0]         = frame_header->loop_filter_level[0],
+        .filter_level[1]         = frame_header->loop_filter_level[1],
+        .filter_level_u          = frame_header->loop_filter_level[2],
+        .filter_level_v          = frame_header->loop_filter_level[3],
+        .base_qindex             = frame_header->base_q_idx,
+        .cdef_damping_minus_3    = frame_header->cdef_damping_minus_3,
+        .cdef_bits               = frame_header->cdef_bits,
+        .seq_info_fields.fields = {
+            .still_picture              = seq->still_picture,
+            .use_128x128_superblock     = seq->use_128x128_superblock,
+            .enable_filter_intra        = seq->enable_filter_intra,
+            .enable_intra_edge_filter   = seq->enable_intra_edge_filter,
+            .enable_interintra_compound = seq->enable_interintra_compound,
+            .enable_masked_compound     = seq->enable_masked_compound,
+            .enable_dual_filter         = seq->enable_dual_filter,
+            .enable_order_hint          = seq->enable_order_hint,
+            .enable_jnt_comp            = seq->enable_jnt_comp,
+            .enable_cdef                = seq->enable_cdef,
+            .mono_chrome                = seq->color_config.mono_chrome,
+            .color_range                = seq->color_config.color_range,
+            .subsampling_x              = seq->color_config.subsampling_x,
+            .subsampling_y              = seq->color_config.subsampling_y,
+            .chroma_sample_position     = seq->color_config.chroma_sample_position,
+            .film_grain_params_present  = seq->film_grain_params_present,
+        },
+        .seg_info.segment_info_fields.bits = {
+            .enabled         = frame_header->segmentation_enabled,
+            .update_map      = frame_header->segmentation_update_map,
+            .temporal_update = frame_header->segmentation_temporal_update,
+            .update_data     = frame_header->segmentation_update_data,
+        },
+        .film_grain_info.film_grain_info_fields.bits = {
+            .apply_grain              = frame_header->apply_grain,
+            .chroma_scaling_from_luma = frame_header->chroma_scaling_from_luma,
+            .grain_scaling_minus_8    = frame_header->grain_scaling_minus_8,
+            .ar_coeff_lag             = frame_header->ar_coeff_lag,
+            .ar_coeff_shift_minus_6   = frame_header->ar_coeff_shift_minus_6,
+            .grain_scale_shift        = frame_header->grain_scale_shift,
+            .overlap_flag             = frame_header->overlap_flag,
+            .clip_to_restricted_range = frame_header->clip_to_restricted_range,
+        },
+        .pic_info_fields.bits = {
+            .frame_type                   = frame_header->frame_type,
+            .show_frame                   = frame_header->show_frame,
+            .showable_frame               = frame_header->showable_frame,
+            .error_resilient_mode         = frame_header->error_resilient_mode,
+            .disable_cdf_update           = frame_header->disable_cdf_update,
+            .allow_screen_content_tools   = frame_header->allow_screen_content_tools,
+            .force_integer_mv             = frame_header->force_integer_mv,
+            .allow_intrabc                = frame_header->allow_intrabc,
+            .use_superres                 = frame_header->use_superres,
+            .allow_high_precision_mv      = frame_header->allow_high_precision_mv,
+            .is_motion_mode_switchable    = frame_header->is_motion_mode_switchable,
+            .use_ref_frame_mvs            = frame_header->use_ref_frame_mvs,
+            .disable_frame_end_update_cdf = frame_header->disable_frame_end_update_cdf,
+            .uniform_tile_spacing_flag    = frame_header->uniform_tile_spacing_flag,
+            .allow_warped_motion          = frame_header->allow_warped_motion,
+        },
+        .loop_filter_info_fields.bits = {
+            .sharpness_level        = frame_header->loop_filter_sharpness,
+            .mode_ref_delta_enabled = s->cur_frame.loop_filter_delta_enabled,
+            .mode_ref_delta_update  = frame_header->loop_filter_delta_update,
+        },
+        .mode_control_fields.bits = {
+            .delta_q_present_flag = frame_header->delta_q_present,
+            .log2_delta_q_res     = frame_header->delta_q_res,
+            .tx_mode              = frame_header->tx_mode,
+            .reference_select     = frame_header->reference_select,
+            .reduced_tx_set_used  = frame_header->reduced_tx_set,
+            .skip_mode_present    = frame_header->skip_mode_present,
+        },
+        .loop_restoration_fields.bits = {
+            .yframe_restoration_type  = remap_lr_type[frame_header->lr_type[0]],
+            .cbframe_restoration_type = remap_lr_type[frame_header->lr_type[1]],
+            .crframe_restoration_type = remap_lr_type[frame_header->lr_type[2]],
+            .lr_unit_shift            = frame_header->lr_unit_shift,
+            .lr_uv_shift              = frame_header->lr_uv_shift,
+        },
+        .qmatrix_fields.bits = {
+            .using_qmatrix = frame_header->using_qmatrix,
+        }
+    };
+
+    for (int i = 0; i < AV1_NUM_REF_FRAMES; i++) {
+        if (pic_param.pic_info_fields.bits.frame_type == AV1_FRAME_KEY)
+            pic_param.ref_frame_map[i] = VA_INVALID_ID;
+        else
+            pic_param.ref_frame_map[i] = vaapi_av1_surface_id(&s->ref[i]);
+    }
+    for (int i = 0; i < AV1_REFS_PER_FRAME; i++) {
+        pic_param.ref_frame_idx[i] = frame_header->ref_frame_idx[i];
+    }
+    for (int i = 0; i < AV1_TOTAL_REFS_PER_FRAME; i++) {
+        pic_param.ref_deltas[i] = s->cur_frame.loop_filter_ref_deltas[i];
+    }
+    for (int i = 0; i < 2; i++) {
+        pic_param.mode_deltas[i] = s->cur_frame.loop_filter_mode_deltas[i];
+    }
+    for (int i = 0; i < (1 << frame_header->cdef_bits); i++) {
+        pic_param.cdef_y_strengths[i] =
+            (frame_header->cdef_y_pri_strength[i] << 2) +
+                frame_header->cdef_y_sec_strength[i];
+        pic_param.cdef_uv_strengths[i] =
+            (frame_header->cdef_uv_pri_strength[i] << 2) +
+                frame_header->cdef_uv_sec_strength[i];
+    }
+    for (int i = 0; i < frame_header->tile_cols; i++) {
+        pic_param.width_in_sbs_minus_1[i] =
+            frame_header->width_in_sbs_minus_1[i];
+    }
+    for (int i = 0; i < frame_header->tile_rows; i++) {
+        pic_param.height_in_sbs_minus_1[i] =
+            frame_header->height_in_sbs_minus_1[i];
+    }
+    for (int i = AV1_REF_FRAME_LAST; i <= AV1_REF_FRAME_ALTREF; i++) {
+        pic_param.wm[i - 1].wmtype = s->cur_frame.gm_type[i];
+        for (int j=0; j<6; j++)
+            pic_param.wm[i - 1].wmmat[j] = s->cur_frame.gm_params[i][j];
+    }
+    err = ff_vaapi_decode_make_param_buffer(avctx, pic,
+                                            VAPictureParameterBufferType,
+                                            &pic_param, sizeof(pic_param));
+    if (err < 0)
+        goto fail;
+
+    return 0;
+
+fail:
+    ff_vaapi_decode_cancel(avctx, pic);
+    return err;
+}
+
+static int vaapi_av1_end_frame(AVCodecContext *avctx)
+{
+    const AV1DecContext *s = avctx->priv_data;
+    VAAPIDecodePicture *pic = s->cur_frame.hwaccel_picture_private;
+    return ff_vaapi_decode_issue(avctx, pic);
+}
+
+static int vaapi_av1_decode_slice(AVCodecContext *avctx,
+                                  const uint8_t *buffer,
+                                  uint32_t size)
+{
+    const AV1DecContext *s = avctx->priv_data;
+    VAAPIDecodePicture *pic = s->cur_frame.hwaccel_picture_private;
+    VASliceParameterBufferAV1 slice_param;
+    int err = 0;
+
+    for (int i = s->tg_start; i <= s->tg_end; i++) {
+        memset(&slice_param, 0, sizeof(VASliceParameterBufferAV1));
+
+        slice_param = (VASliceParameterBufferAV1) {
+            .slice_data_size   = s->tile_group_info[i].tile_size,
+            .slice_data_offset = s->tile_group_info[i].tile_offset,
+            .slice_data_flag   = VA_SLICE_DATA_FLAG_ALL,
+            .tile_row          = s->tile_group_info[i].tile_row,
+            .tile_column       = s->tile_group_info[i].tile_column,
+            .tg_start          = s->tg_start,
+            .tg_end            = s->tg_end,
+        };
+
+        err = ff_vaapi_decode_make_slice_buffer(avctx, pic, &slice_param,
+                                                sizeof(VASliceParameterBufferAV1),
+                                                buffer,
+                                                s->tile_group_info[i].tile_size);
+        if (err) {
+            ff_vaapi_decode_cancel(avctx, pic);
+            return err;
+        }
+    }
+
+    return 0;
+}
+
+const AVHWAccel ff_av1_vaapi_hwaccel = {
+    .name                 = "av1_vaapi",
+    .type                 = AVMEDIA_TYPE_VIDEO,
+    .id                   = AV_CODEC_ID_AV1,
+    .pix_fmt              = AV_PIX_FMT_VAAPI,
+    .start_frame          = vaapi_av1_start_frame,
+    .end_frame            = vaapi_av1_end_frame,
+    .decode_slice         = vaapi_av1_decode_slice,
+    .frame_priv_data_size = sizeof(VAAPIDecodePicture),
+    .init                 = ff_vaapi_decode_init,
+    .uninit               = ff_vaapi_decode_uninit,
+    .frame_params         = ff_vaapi_common_frame_params,
+    .priv_data_size       = sizeof(VAAPIDecodeContext),
+    .caps_internal        = HWACCEL_CAP_ASYNC_SAFE,
+};
diff --git a/libavcodec/vaapi_decode.c b/libavcodec/vaapi_decode.c
index 5e4f62baad..57a0eb4e6e 100644
--- a/libavcodec/vaapi_decode.c
+++ b/libavcodec/vaapi_decode.c
@@ -410,6 +410,11 @@  static const struct {
 #if VA_CHECK_VERSION(0, 39, 0)
     MAP(VP9,         VP9_2,           VP9Profile2 ),
 #endif
+#if VA_CHECK_VERSION(1, 8, 0)
+    MAP(AV1,         AV1_MAIN,        AV1Profile0),
+    MAP(AV1,         AV1_HIGH,        AV1Profile1),
+#endif
+
 #undef MAP
 };
 
@@ -575,6 +580,7 @@  static int vaapi_decode_make_config(AVCodecContext *avctx,
             frames->initial_pool_size += 16;
             break;
         case AV_CODEC_ID_VP9:
+        case AV_CODEC_ID_AV1:
             frames->initial_pool_size += 8;
             break;
         case AV_CODEC_ID_VP8:
diff --git a/libavcodec/version.h b/libavcodec/version.h
index 5f873a5cea..4566d317e4 100644
--- a/libavcodec/version.h
+++ b/libavcodec/version.h
@@ -29,7 +29,7 @@ 
 
 #define LIBAVCODEC_VERSION_MAJOR  58
 #define LIBAVCODEC_VERSION_MINOR 108
-#define LIBAVCODEC_VERSION_MICRO 100
+#define LIBAVCODEC_VERSION_MICRO 101
 
 #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
                                                LIBAVCODEC_VERSION_MINOR, \