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

   1 /*
   2  * AV1 HW decode acceleration through VA API
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include "libavutil/pixdesc.h"
  22 #include "hwconfig.h"
  23 #include "vaapi_decode.h"
  24 #include "av1dec.h"
  25
  26 static VASurfaceID vaapi_av1_surface_id(AV1Frame *vf)
  27 {
  28     if (vf)
  29         return ff_vaapi_get_surface_id(vf->tf.f);
  30     else
  31         return VA_INVALID_SURFACE;
  32 }
  33
  34 static int8_t vaapi_av1_get_bit_depth_idx(AVCodecContext *avctx)
  35 {
  36     AV1DecContext *s = avctx->priv_data;
  37     const AV1RawSequenceHeader *seq = s->raw_seq;
  38     int8_t bit_depth = 8;
  39
  40     if (seq->seq_profile == 2 && seq->color_config.high_bitdepth)
  41         bit_depth = seq->color_config.twelve_bit ? 12 : 10;
  42     else if (seq->seq_profile <= 2)
  43         bit_depth = seq->color_config.high_bitdepth ? 10 : 8;
  44     else {
  45         av_log(avctx, AV_LOG_ERROR,
  46                "Couldn't get bit depth from profile:%d.\n", seq->seq_profile);
  47         return -1;
  48     }
  49     return bit_depth == 8 ? 0 : bit_depth == 10 ? 1 : 2;
  50 }
  51
  52 static int vaapi_av1_start_frame(AVCodecContext *avctx,
  53                                  av_unused const uint8_t *buffer,
  54                                  av_unused uint32_t size)
  55 {
  56     AV1DecContext *s = avctx->priv_data;
  57     const AV1RawSequenceHeader *seq = s->raw_seq;
  58     const AV1RawFrameHeader *frame_header = s->raw_frame_header;
  59     const AV1RawFilmGrainParams *film_grain = &s->cur_frame.film_grain;
  60     VAAPIDecodePicture *pic = s->cur_frame.hwaccel_picture_private;
  61     VADecPictureParameterBufferAV1 pic_param;
  62     int8_t bit_depth_idx;
  63     int err = 0;
  64     uint8_t remap_lr_type[4] = {AV1_RESTORE_NONE, AV1_RESTORE_SWITCHABLE, AV1_RESTORE_WIENER, AV1_RESTORE_SGRPROJ};
  65
  66     pic->output_surface = vaapi_av1_surface_id(&s->cur_frame);
  67
  68     bit_depth_idx = vaapi_av1_get_bit_depth_idx(avctx);
  69     if (bit_depth_idx < 0)
  70         goto fail;
  71
  72     memset(&pic_param, 0, sizeof(VADecPictureParameterBufferAV1));
  73     pic_param = (VADecPictureParameterBufferAV1) {
  74         .profile                 = seq->seq_profile,
  75         .order_hint_bits_minus_1 = seq->order_hint_bits_minus_1,
  76         .bit_depth_idx           = bit_depth_idx,
  77         .current_frame           = pic->output_surface,
  78         .current_display_picture = pic->output_surface,
  79         .frame_width_minus1      = frame_header->frame_width_minus_1,
  80         .frame_height_minus1     = frame_header->frame_height_minus_1,
  81         .primary_ref_frame       = frame_header->primary_ref_frame,
  82         .order_hint              = frame_header->order_hint,
  83         .tile_cols               = frame_header->tile_cols,
  84         .tile_rows               = frame_header->tile_rows,
  85         .context_update_tile_id  = frame_header->context_update_tile_id,
  86         .interp_filter           = frame_header->interpolation_filter,
  87         .filter_level[0]         = frame_header->loop_filter_level[0],
  88         .filter_level[1]         = frame_header->loop_filter_level[1],
  89         .filter_level_u          = frame_header->loop_filter_level[2],
  90         .filter_level_v          = frame_header->loop_filter_level[3],
  91         .base_qindex             = frame_header->base_q_idx,
  92         .cdef_damping_minus_3    = frame_header->cdef_damping_minus_3,
  93         .cdef_bits               = frame_header->cdef_bits,
  94         .seq_info_fields.fields = {
  95             .still_picture              = seq->still_picture,
  96             .use_128x128_superblock     = seq->use_128x128_superblock,
  97             .enable_filter_intra        = seq->enable_filter_intra,
  98             .enable_intra_edge_filter   = seq->enable_intra_edge_filter,
  99             .enable_interintra_compound = seq->enable_interintra_compound,
 100             .enable_masked_compound     = seq->enable_masked_compound,
 101             .enable_dual_filter         = seq->enable_dual_filter,
 102             .enable_order_hint          = seq->enable_order_hint,
 103             .enable_jnt_comp            = seq->enable_jnt_comp,
 104             .enable_cdef                = seq->enable_cdef,
 105             .mono_chrome                = seq->color_config.mono_chrome,
 106             .color_range                = seq->color_config.color_range,
 107             .subsampling_x              = seq->color_config.subsampling_x,
 108             .subsampling_y              = seq->color_config.subsampling_y,
 109             .chroma_sample_position     = seq->color_config.chroma_sample_position,
 110             .film_grain_params_present  = seq->film_grain_params_present,
 111         },
 112         .seg_info.segment_info_fields.bits = {
 113             .enabled         = frame_header->segmentation_enabled,
 114             .update_map      = frame_header->segmentation_update_map,
 115             .temporal_update = frame_header->segmentation_temporal_update,
 116             .update_data     = frame_header->segmentation_update_data,
 117         },
 118         .film_grain_info.film_grain_info_fields.bits = {
 119             .apply_grain              = film_grain->apply_grain,
 120             .chroma_scaling_from_luma = film_grain->chroma_scaling_from_luma,
 121             .grain_scaling_minus_8    = film_grain->grain_scaling_minus_8,
 122             .ar_coeff_lag             = film_grain->ar_coeff_lag,
 123             .ar_coeff_shift_minus_6   = film_grain->ar_coeff_shift_minus_6,
 124             .grain_scale_shift        = film_grain->grain_scale_shift,
 125             .overlap_flag             = film_grain->overlap_flag,
 126             .clip_to_restricted_range = film_grain->clip_to_restricted_range,
 127         },
 128         .pic_info_fields.bits = {
 129             .frame_type                   = frame_header->frame_type,
 130             .show_frame                   = frame_header->show_frame,
 131             .showable_frame               = frame_header->showable_frame,
 132             .error_resilient_mode         = frame_header->error_resilient_mode,
 133             .disable_cdf_update           = frame_header->disable_cdf_update,
 134             .allow_screen_content_tools   = frame_header->allow_screen_content_tools,
 135             .force_integer_mv             = frame_header->force_integer_mv,
 136             .allow_intrabc                = frame_header->allow_intrabc,
 137             .use_superres                 = frame_header->use_superres,
 138             .allow_high_precision_mv      = frame_header->allow_high_precision_mv,
 139             .is_motion_mode_switchable    = frame_header->is_motion_mode_switchable,
 140             .use_ref_frame_mvs            = frame_header->use_ref_frame_mvs,
 141             .disable_frame_end_update_cdf = frame_header->disable_frame_end_update_cdf,
 142             .uniform_tile_spacing_flag    = frame_header->uniform_tile_spacing_flag,
 143             .allow_warped_motion          = frame_header->allow_warped_motion,
 144         },
 145         .loop_filter_info_fields.bits = {
 146             .sharpness_level        = frame_header->loop_filter_sharpness,
 147             .mode_ref_delta_enabled = frame_header->loop_filter_delta_enabled,
 148             .mode_ref_delta_update  = frame_header->loop_filter_delta_update,
 149         },
 150         .mode_control_fields.bits = {
 151             .delta_q_present_flag = frame_header->delta_q_present,
 152             .log2_delta_q_res     = frame_header->delta_q_res,
 153             .tx_mode              = frame_header->tx_mode,
 154             .reference_select     = frame_header->reference_select,
 155             .reduced_tx_set_used  = frame_header->reduced_tx_set,
 156             .skip_mode_present    = frame_header->skip_mode_present,
 157         },
 158         .loop_restoration_fields.bits = {
 159             .yframe_restoration_type  = remap_lr_type[frame_header->lr_type[0]],
 160             .cbframe_restoration_type = remap_lr_type[frame_header->lr_type[1]],
 161             .crframe_restoration_type = remap_lr_type[frame_header->lr_type[2]],
 162             .lr_unit_shift            = frame_header->lr_unit_shift,
 163             .lr_uv_shift              = frame_header->lr_uv_shift,
 164         },
 165         .qmatrix_fields.bits = {
 166             .using_qmatrix = frame_header->using_qmatrix,
 167         }
 168     };
 169
 170     for (int i = 0; i < AV1_NUM_REF_FRAMES; i++) {
 171         if (pic_param.pic_info_fields.bits.frame_type == AV1_FRAME_KEY)
 172             pic_param.ref_frame_map[i] = VA_INVALID_ID;
 173         else
 174             pic_param.ref_frame_map[i] = vaapi_av1_surface_id(&s->ref[i]);
 175     }
 176     for (int i = 0; i < AV1_REFS_PER_FRAME; i++) {
 177         pic_param.ref_frame_idx[i] = frame_header->ref_frame_idx[i];
 178     }
 179     for (int i = 0; i < AV1_TOTAL_REFS_PER_FRAME; i++) {
 180         pic_param.ref_deltas[i] = frame_header->loop_filter_ref_deltas[i];
 181     }
 182     for (int i = 0; i < 2; i++) {
 183         pic_param.mode_deltas[i] = frame_header->loop_filter_mode_deltas[i];
 184     }
 185     for (int i = 0; i < (1 << frame_header->cdef_bits); i++) {
 186         pic_param.cdef_y_strengths[i] =
 187             (frame_header->cdef_y_pri_strength[i] << 2) +
 188                 frame_header->cdef_y_sec_strength[i];
 189         pic_param.cdef_uv_strengths[i] =
 190             (frame_header->cdef_uv_pri_strength[i] << 2) +
 191                 frame_header->cdef_uv_sec_strength[i];
 192     }
 193     for (int i = 0; i < frame_header->tile_cols; i++) {
 194         pic_param.width_in_sbs_minus_1[i] =
 195             frame_header->width_in_sbs_minus_1[i];
 196     }
 197     for (int i = 0; i < frame_header->tile_rows; i++) {
 198         pic_param.height_in_sbs_minus_1[i] =
 199             frame_header->height_in_sbs_minus_1[i];
 200     }
 201     for (int i = AV1_REF_FRAME_LAST; i <= AV1_REF_FRAME_ALTREF; i++) {
 202         pic_param.wm[i - 1].wmtype = s->cur_frame.gm_type[i];
 203         for (int j = 0; j < 6; j++)
 204             pic_param.wm[i - 1].wmmat[j] = s->cur_frame.gm_params[i][j];
 205     }
 206     err = ff_vaapi_decode_make_param_buffer(avctx, pic,
 207                                             VAPictureParameterBufferType,
 208                                             &pic_param, sizeof(pic_param));
 209     if (err < 0)
 210         goto fail;
 211
 212     return 0;
 213
 214 fail:
 215     ff_vaapi_decode_cancel(avctx, pic);
 216     return err;
 217 }
 218
 219 static int vaapi_av1_end_frame(AVCodecContext *avctx)
 220 {
 221     const AV1DecContext *s = avctx->priv_data;
 222     VAAPIDecodePicture *pic = s->cur_frame.hwaccel_picture_private;
 223     return ff_vaapi_decode_issue(avctx, pic);
 224 }
 225
 226 static int vaapi_av1_decode_slice(AVCodecContext *avctx,
 227                                   const uint8_t *buffer,
 228                                   uint32_t size)
 229 {
 230     const AV1DecContext *s = avctx->priv_data;
 231     VAAPIDecodePicture *pic = s->cur_frame.hwaccel_picture_private;
 232     VASliceParameterBufferAV1 slice_param;
 233     int err = 0;
 234
 235     for (int i = s->tg_start; i <= s->tg_end; i++) {
 236         memset(&slice_param, 0, sizeof(VASliceParameterBufferAV1));
 237
 238         slice_param = (VASliceParameterBufferAV1) {
 239             .slice_data_size   = s->tile_group_info[i].tile_size,
 240             .slice_data_offset = s->tile_group_info[i].tile_offset,
 241             .slice_data_flag   = VA_SLICE_DATA_FLAG_ALL,
 242             .tile_row          = s->tile_group_info[i].tile_row,
 243             .tile_column       = s->tile_group_info[i].tile_column,
 244             .tg_start          = s->tg_start,
 245             .tg_end            = s->tg_end,
 246         };
 247
 248         err = ff_vaapi_decode_make_slice_buffer(avctx, pic, &slice_param,
 249                                                 sizeof(VASliceParameterBufferAV1),
 250                                                 buffer,
 251                                                 s->tile_group_info[i].tile_size);
 252         if (err) {
 253             ff_vaapi_decode_cancel(avctx, pic);
 254             return err;
 255         }
 256     }
 257
 258     return 0;
 259 }
 260
 261 const AVHWAccel ff_av1_vaapi_hwaccel = {
 262     .name                 = "av1_vaapi",
 263     .type                 = AVMEDIA_TYPE_VIDEO,
 264     .id                   = AV_CODEC_ID_AV1,
 265     .pix_fmt              = AV_PIX_FMT_VAAPI,
 266     .start_frame          = vaapi_av1_start_frame,
 267     .end_frame            = vaapi_av1_end_frame,
 268     .decode_slice         = vaapi_av1_decode_slice,
 269     .frame_priv_data_size = sizeof(VAAPIDecodePicture),
 270     .init                 = ff_vaapi_decode_init,
 271     .uninit               = ff_vaapi_decode_uninit,
 272     .frame_params         = ff_vaapi_common_frame_params,
 273     .priv_data_size       = sizeof(VAAPIDecodeContext),
 274     .caps_internal        = HWACCEL_CAP_ASYNC_SAFE,
 275 };