X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fvaapi_encode_h264.c;h=ff37de1f7ea37d7c9c8173bf66eb1f83ebd1082f;hb=a247ac640df3da573cd661065bf53f37863e2b46;hp=8feae0d42fb1036d209b788c859a004bf754c552;hpb=4b2e3de8c0fc87bfddd98cfab95bb1afe63c7fff;p=ffmpeg diff --git a/libavcodec/vaapi_encode_h264.c b/libavcodec/vaapi_encode_h264.c index 8feae0d42fb..ff37de1f7ea 100644 --- a/libavcodec/vaapi_encode_h264.c +++ b/libavcodec/vaapi_encode_h264.c @@ -47,6 +47,20 @@ static const uint8_t vaapi_encode_h264_sei_identifier_uuid[16] = { 0x96, 0x75, 0x19, 0xd4, 0x1f, 0xea, 0xa9, 0x4d, }; +typedef struct VAAPIEncodeH264Picture { + int frame_num; + int pic_order_cnt; + + int64_t last_idr_frame; + uint16_t idr_pic_id; + + int primary_pic_type; + int slice_type; + + int cpb_delay; + int dpb_delay; +} VAAPIEncodeH264Picture; + typedef struct VAAPIEncodeH264Context { VAAPIEncodeContext common; @@ -67,18 +81,7 @@ typedef struct VAAPIEncodeH264Context { int fixed_qp_p; int fixed_qp_b; - // Stream state. - int frame_num; - int pic_order_cnt; - int next_frame_num; - int64_t last_idr_frame; - int64_t idr_pic_count; - - int primary_pic_type; - int slice_type; - - int cpb_delay; - int dpb_delay; + int dpb_frames; // Writer structures. CodedBitstreamContext *cbc; @@ -87,13 +90,12 @@ typedef struct VAAPIEncodeH264Context { H264RawAUD raw_aud; H264RawSPS raw_sps; H264RawPPS raw_pps; - H264RawSEI raw_sei; H264RawSlice raw_slice; H264RawSEIBufferingPeriod sei_buffering_period; H264RawSEIPicTiming sei_pic_timing; H264RawSEIRecoveryPoint sei_recovery_point; - H264RawSEIUserDataUnregistered sei_identifier; + SEIRawUserDataUnregistered sei_identifier; char *sei_identifier_string; int aud_needed; @@ -132,11 +134,10 @@ static int vaapi_encode_h264_add_nal(AVCodecContext *avctx, CodedBitstreamFragment *au, void *nal_unit) { - VAAPIEncodeH264Context *priv = avctx->priv_data; H264RawNALUnitHeader *header = nal_unit; int err; - err = ff_cbs_insert_unit_content(priv->cbc, au, -1, + err = ff_cbs_insert_unit_content(au, -1, header->nal_unit_type, nal_unit, NULL); if (err < 0) { av_log(avctx, AV_LOG_ERROR, "Failed to add NAL unit: " @@ -171,7 +172,7 @@ static int vaapi_encode_h264_write_sequence_header(AVCodecContext *avctx, err = vaapi_encode_h264_write_access_unit(avctx, data, data_len, au); fail: - ff_cbs_fragment_uninit(priv->cbc, au); + ff_cbs_fragment_reset(au); return err; } @@ -197,7 +198,7 @@ static int vaapi_encode_h264_write_slice_header(AVCodecContext *avctx, err = vaapi_encode_h264_write_access_unit(avctx, data, data_len, au); fail: - ff_cbs_fragment_uninit(priv->cbc, au); + ff_cbs_fragment_reset(au); return err; } @@ -208,11 +209,9 @@ static int vaapi_encode_h264_write_extra_header(AVCodecContext *avctx, { VAAPIEncodeH264Context *priv = avctx->priv_data; CodedBitstreamFragment *au = &priv->current_access_unit; - int err, i; + int err; if (priv->sei_needed) { - H264RawSEI *sei = &priv->raw_sei; - if (priv->aud_needed) { err = vaapi_encode_h264_add_nal(avctx, au, &priv->raw_aud); if (err < 0) @@ -220,48 +219,42 @@ static int vaapi_encode_h264_write_extra_header(AVCodecContext *avctx, priv->aud_needed = 0; } - *sei = (H264RawSEI) { - .nal_unit_header = { - .nal_unit_type = H264_NAL_SEI, - }, - }; - - i = 0; - if (priv->sei_needed & SEI_IDENTIFIER) { - sei->payload[i].payload_type = H264_SEI_TYPE_USER_DATA_UNREGISTERED; - sei->payload[i].payload.user_data_unregistered = priv->sei_identifier; - ++i; + err = ff_cbs_sei_add_message(priv->cbc, au, 1, + SEI_TYPE_USER_DATA_UNREGISTERED, + &priv->sei_identifier, NULL); + if (err < 0) + goto fail; } if (priv->sei_needed & SEI_TIMING) { if (pic->type == PICTURE_TYPE_IDR) { - sei->payload[i].payload_type = H264_SEI_TYPE_BUFFERING_PERIOD; - sei->payload[i].payload.buffering_period = priv->sei_buffering_period; - ++i; + err = ff_cbs_sei_add_message(priv->cbc, au, 1, + SEI_TYPE_BUFFERING_PERIOD, + &priv->sei_buffering_period, NULL); + if (err < 0) + goto fail; } - sei->payload[i].payload_type = H264_SEI_TYPE_PIC_TIMING; - sei->payload[i].payload.pic_timing = priv->sei_pic_timing; - ++i; + err = ff_cbs_sei_add_message(priv->cbc, au, 1, + SEI_TYPE_PIC_TIMING, + &priv->sei_pic_timing, NULL); + if (err < 0) + goto fail; } if (priv->sei_needed & SEI_RECOVERY_POINT) { - sei->payload[i].payload_type = H264_SEI_TYPE_RECOVERY_POINT; - sei->payload[i].payload.recovery_point = priv->sei_recovery_point; - ++i; + err = ff_cbs_sei_add_message(priv->cbc, au, 1, + SEI_TYPE_RECOVERY_POINT, + &priv->sei_recovery_point, NULL); + if (err < 0) + goto fail; } - sei->payload_count = i; - av_assert0(sei->payload_count > 0); - - err = vaapi_encode_h264_add_nal(avctx, au, sei); - if (err < 0) - goto fail; priv->sei_needed = 0; err = vaapi_encode_h264_write_access_unit(avctx, data, data_len, au); if (err < 0) goto fail; - ff_cbs_fragment_uninit(priv->cbc, au); + ff_cbs_fragment_reset(au); *type = VAEncPackedHeaderRawData; return 0; @@ -283,7 +276,7 @@ static int vaapi_encode_h264_write_extra_header(AVCodecContext *avctx, } fail: - ff_cbs_fragment_uninit(priv->cbc, au); + ff_cbs_fragment_reset(au); return err; } @@ -295,10 +288,6 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx) H264RawPPS *pps = &priv->raw_pps; VAEncSequenceParameterBufferH264 *vseq = ctx->codec_sequence_params; VAEncPictureParameterBufferH264 *vpic = ctx->codec_picture_params; - int dpb_frames; - - memset(&priv->current_access_unit, 0, - sizeof(priv->current_access_unit)); memset(sps, 0, sizeof(*sps)); memset(pps, 0, sizeof(*pps)); @@ -322,20 +311,27 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx) } if (ctx->gop_size == 1) - dpb_frames = 0; + priv->dpb_frames = 0; else - dpb_frames = 1 + (ctx->b_per_p > 0); + priv->dpb_frames = 1 + ctx->max_b_depth; if (avctx->level != FF_LEVEL_UNKNOWN) { sps->level_idc = avctx->level; } else { const H264LevelDescriptor *level; + int framerate; + + if (avctx->framerate.num > 0 && avctx->framerate.den > 0) + framerate = avctx->framerate.num / avctx->framerate.den; + else + framerate = 0; level = ff_h264_guess_level(sps->profile_idc, avctx->bit_rate, + framerate, priv->mb_width * 16, priv->mb_height * 16, - dpb_frames); + priv->dpb_frames); if (level) { av_log(avctx, AV_LOG_VERBOSE, "Using level %s.\n", level->name); if (level->constraint_set3_flag) @@ -353,10 +349,9 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx) sps->log2_max_frame_num_minus4 = 4; sps->pic_order_cnt_type = 0; - sps->log2_max_pic_order_cnt_lsb_minus4 = - av_clip(av_log2(ctx->b_per_p + 1) - 2, 0, 12); + sps->log2_max_pic_order_cnt_lsb_minus4 = 4; - sps->max_num_ref_frames = dpb_frames; + sps->max_num_ref_frames = priv->dpb_frames; sps->pic_width_in_mbs_minus1 = priv->mb_width - 1; sps->pic_height_in_map_units_minus1 = priv->mb_height - 1; @@ -389,46 +384,38 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx) { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 }, { 160, 99 }, { 4, 3 }, { 3, 2 }, { 2, 1 }, }; - int i; + int num, den, i; + av_reduce(&num, &den, avctx->sample_aspect_ratio.num, + avctx->sample_aspect_ratio.den, 65535); for (i = 0; i < FF_ARRAY_ELEMS(sar_idc); i++) { - if (avctx->sample_aspect_ratio.num == sar_idc[i].num && - avctx->sample_aspect_ratio.den == sar_idc[i].den) { + if (num == sar_idc[i].num && + den == sar_idc[i].den) { sps->vui.aspect_ratio_idc = i; break; } } if (i >= FF_ARRAY_ELEMS(sar_idc)) { sps->vui.aspect_ratio_idc = 255; - sps->vui.sar_width = avctx->sample_aspect_ratio.num; - sps->vui.sar_height = avctx->sample_aspect_ratio.den; + sps->vui.sar_width = num; + sps->vui.sar_height = den; } sps->vui.aspect_ratio_info_present_flag = 1; } - if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED || - avctx->color_primaries != AVCOL_PRI_UNSPECIFIED || + // Unspecified video format, from table E-2. + sps->vui.video_format = 5; + sps->vui.video_full_range_flag = + avctx->color_range == AVCOL_RANGE_JPEG; + sps->vui.colour_primaries = avctx->color_primaries; + sps->vui.transfer_characteristics = avctx->color_trc; + sps->vui.matrix_coefficients = avctx->colorspace; + if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED || avctx->color_trc != AVCOL_TRC_UNSPECIFIED || - avctx->colorspace != AVCOL_SPC_UNSPECIFIED) { + avctx->colorspace != AVCOL_SPC_UNSPECIFIED) + sps->vui.colour_description_present_flag = 1; + if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED || + sps->vui.colour_description_present_flag) sps->vui.video_signal_type_present_flag = 1; - sps->vui.video_format = 5; // Unspecified. - sps->vui.video_full_range_flag = - avctx->color_range == AVCOL_RANGE_JPEG; - - if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED || - avctx->color_trc != AVCOL_TRC_UNSPECIFIED || - avctx->colorspace != AVCOL_SPC_UNSPECIFIED) { - sps->vui.colour_description_present_flag = 1; - sps->vui.colour_primaries = avctx->color_primaries; - sps->vui.transfer_characteristics = avctx->color_trc; - sps->vui.matrix_coefficients = avctx->colorspace; - } - } else { - sps->vui.video_format = 5; - sps->vui.video_full_range_flag = 0; - sps->vui.colour_primaries = avctx->color_primaries; - sps->vui.transfer_characteristics = avctx->color_trc; - sps->vui.matrix_coefficients = avctx->colorspace; - } if (avctx->chroma_sample_location != AVCHROMA_LOC_UNSPECIFIED) { sps->vui.chroma_loc_info_present_flag = 1; @@ -464,9 +451,9 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx) (ctx->va_bit_rate >> hrd->bit_rate_scale + 6) - 1; hrd->cpb_size_scale = - av_clip_uintp2(av_log2(ctx->hrd_params.hrd.buffer_size) - 15 - 4, 4); + av_clip_uintp2(av_log2(ctx->hrd_params.buffer_size) - 15 - 4, 4); hrd->cpb_size_value_minus1[0] = - (ctx->hrd_params.hrd.buffer_size >> hrd->cpb_size_scale + 4) - 1; + (ctx->hrd_params.buffer_size >> hrd->cpb_size_scale + 4) - 1; // CBR mode as defined for the HRD cannot be achieved without filler // data, so this flag cannot be set even with VAAPI CBR modes. @@ -481,8 +468,8 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx) // This calculation can easily overflow 32 bits. bp->nal.initial_cpb_removal_delay[0] = 90000 * - (uint64_t)ctx->hrd_params.hrd.initial_buffer_fullness / - ctx->hrd_params.hrd.buffer_size; + (uint64_t)ctx->hrd_params.initial_buffer_fullness / + ctx->hrd_params.buffer_size; bp->nal.initial_cpb_removal_delay_offset[0] = 0; } else { sps->vui.nal_hrd_parameters_present_flag = 0; @@ -493,8 +480,8 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx) sps->vui.motion_vectors_over_pic_boundaries_flag = 1; sps->vui.log2_max_mv_length_horizontal = 15; sps->vui.log2_max_mv_length_vertical = 15; - sps->vui.max_num_reorder_frames = (ctx->b_per_p > 0); - sps->vui.max_dec_frame_buffering = sps->max_num_ref_frames; + sps->vui.max_num_reorder_frames = ctx->max_b_depth; + sps->vui.max_dec_frame_buffering = ctx->max_b_depth + 1; pps->nal_unit_header.nal_ref_idc = 3; pps->nal_unit_header.nal_unit_type = H264_NAL_PPS; @@ -615,46 +602,43 @@ static int vaapi_encode_h264_init_picture_params(AVCodecContext *avctx, { VAAPIEncodeContext *ctx = avctx->priv_data; VAAPIEncodeH264Context *priv = avctx->priv_data; - H264RawSPS *sps = &priv->raw_sps; + VAAPIEncodeH264Picture *hpic = pic->priv_data; + VAAPIEncodePicture *prev = pic->prev; + VAAPIEncodeH264Picture *hprev = prev ? prev->priv_data : NULL; VAEncPictureParameterBufferH264 *vpic = pic->codec_picture_params; int i; - memset(&priv->current_access_unit, 0, - sizeof(priv->current_access_unit)); - if (pic->type == PICTURE_TYPE_IDR) { av_assert0(pic->display_order == pic->encode_order); - priv->frame_num = 0; - priv->next_frame_num = 1; - priv->cpb_delay = 0; - priv->last_idr_frame = pic->display_order; - ++priv->idr_pic_count; - - priv->slice_type = 7; - priv->primary_pic_type = 0; + + hpic->frame_num = 0; + hpic->last_idr_frame = pic->display_order; + hpic->idr_pic_id = hprev ? hprev->idr_pic_id + 1 : 0; + + hpic->primary_pic_type = 0; + hpic->slice_type = 7; } else { - priv->frame_num = priv->next_frame_num; + av_assert0(prev); - if (pic->type != PICTURE_TYPE_B) { - // Reference picture, so frame_num advances. - priv->next_frame_num = (priv->frame_num + 1) & - ((1 << (4 + sps->log2_max_frame_num_minus4)) - 1); - } - ++priv->cpb_delay; + hpic->frame_num = hprev->frame_num + prev->is_reference; + + hpic->last_idr_frame = hprev->last_idr_frame; + hpic->idr_pic_id = hprev->idr_pic_id; if (pic->type == PICTURE_TYPE_I) { - priv->slice_type = 7; - priv->primary_pic_type = 0; + hpic->slice_type = 7; + hpic->primary_pic_type = 0; } else if (pic->type == PICTURE_TYPE_P) { - priv->slice_type = 5; - priv->primary_pic_type = 1; + hpic->slice_type = 5; + hpic->primary_pic_type = 1; } else { - priv->slice_type = 6; - priv->primary_pic_type = 2; + hpic->slice_type = 6; + hpic->primary_pic_type = 2; } } - priv->pic_order_cnt = pic->display_order - priv->last_idr_frame; - priv->dpb_delay = pic->display_order - pic->encode_order + 1; + hpic->pic_order_cnt = pic->display_order - hpic->last_idr_frame; + hpic->dpb_delay = pic->display_order - pic->encode_order + ctx->max_b_depth; + hpic->cpb_delay = pic->encode_order - hpic->last_idr_frame; if (priv->aud) { priv->aud_needed = 1; @@ -662,7 +646,7 @@ static int vaapi_encode_h264_init_picture_params(AVCodecContext *avctx, .nal_unit_header = { .nal_unit_type = H264_NAL_AUD, }, - .primary_pic_type = priv->primary_pic_type, + .primary_pic_type = hpic->primary_pic_type, }; } else { priv->aud_needed = 0; @@ -679,8 +663,8 @@ static int vaapi_encode_h264_init_picture_params(AVCodecContext *avctx, if (priv->sei & SEI_TIMING) { priv->sei_pic_timing = (H264RawSEIPicTiming) { - .cpb_removal_delay = 2 * priv->cpb_delay, - .dpb_output_delay = 2 * priv->dpb_delay, + .cpb_removal_delay = 2 * hpic->cpb_delay, + .dpb_output_delay = 2 * hpic->dpb_delay, }; priv->sei_needed |= SEI_TIMING; @@ -698,25 +682,25 @@ static int vaapi_encode_h264_init_picture_params(AVCodecContext *avctx, vpic->CurrPic = (VAPictureH264) { .picture_id = pic->recon_surface, - .frame_idx = priv->frame_num, + .frame_idx = hpic->frame_num, .flags = 0, - .TopFieldOrderCnt = priv->pic_order_cnt, - .BottomFieldOrderCnt = priv->pic_order_cnt, + .TopFieldOrderCnt = hpic->pic_order_cnt, + .BottomFieldOrderCnt = hpic->pic_order_cnt, }; for (i = 0; i < pic->nb_refs; i++) { - VAAPIEncodePicture *ref = pic->refs[i]; - unsigned int frame_num = (ref->encode_order - priv->last_idr_frame) & - ((1 << (4 + sps->log2_max_frame_num_minus4)) - 1); - unsigned int pic_order_cnt = ref->display_order - priv->last_idr_frame; + VAAPIEncodePicture *ref = pic->refs[i]; + VAAPIEncodeH264Picture *href; av_assert0(ref && ref->encode_order < pic->encode_order); + href = ref->priv_data; + vpic->ReferenceFrames[i] = (VAPictureH264) { .picture_id = ref->recon_surface, - .frame_idx = frame_num, + .frame_idx = href->frame_num, .flags = VA_PICTURE_H264_SHORT_TERM_REFERENCE, - .TopFieldOrderCnt = pic_order_cnt, - .BottomFieldOrderCnt = pic_order_cnt, + .TopFieldOrderCnt = href->pic_order_cnt, + .BottomFieldOrderCnt = href->pic_order_cnt, }; } for (; i < FF_ARRAY_ELEMS(vpic->ReferenceFrames); i++) { @@ -728,46 +712,142 @@ static int vaapi_encode_h264_init_picture_params(AVCodecContext *avctx, vpic->coded_buf = pic->output_buffer; - vpic->frame_num = priv->frame_num; + vpic->frame_num = hpic->frame_num; vpic->pic_fields.bits.idr_pic_flag = (pic->type == PICTURE_TYPE_IDR); vpic->pic_fields.bits.reference_pic_flag = (pic->type != PICTURE_TYPE_B); - pic->nb_slices = 1; - return 0; } +static void vaapi_encode_h264_default_ref_pic_list(AVCodecContext *avctx, + VAAPIEncodePicture *pic, + VAAPIEncodePicture **rpl0, + VAAPIEncodePicture **rpl1, + int *rpl_size) +{ + VAAPIEncodePicture *prev; + VAAPIEncodeH264Picture *hp, *hn, *hc; + int i, j, n = 0; + + prev = pic->prev; + av_assert0(prev); + hp = pic->priv_data; + + for (i = 0; i < pic->prev->nb_dpb_pics; i++) { + hn = prev->dpb[i]->priv_data; + av_assert0(hn->frame_num < hp->frame_num); + + if (pic->type == PICTURE_TYPE_P) { + for (j = n; j > 0; j--) { + hc = rpl0[j - 1]->priv_data; + av_assert0(hc->frame_num != hn->frame_num); + if (hc->frame_num > hn->frame_num) + break; + rpl0[j] = rpl0[j - 1]; + } + rpl0[j] = prev->dpb[i]; + + } else if (pic->type == PICTURE_TYPE_B) { + for (j = n; j > 0; j--) { + hc = rpl0[j - 1]->priv_data; + av_assert0(hc->pic_order_cnt != hp->pic_order_cnt); + if (hc->pic_order_cnt < hp->pic_order_cnt) { + if (hn->pic_order_cnt > hp->pic_order_cnt || + hn->pic_order_cnt < hc->pic_order_cnt) + break; + } else { + if (hn->pic_order_cnt > hc->pic_order_cnt) + break; + } + rpl0[j] = rpl0[j - 1]; + } + rpl0[j] = prev->dpb[i]; + + for (j = n; j > 0; j--) { + hc = rpl1[j - 1]->priv_data; + av_assert0(hc->pic_order_cnt != hp->pic_order_cnt); + if (hc->pic_order_cnt > hp->pic_order_cnt) { + if (hn->pic_order_cnt < hp->pic_order_cnt || + hn->pic_order_cnt > hc->pic_order_cnt) + break; + } else { + if (hn->pic_order_cnt < hc->pic_order_cnt) + break; + } + rpl1[j] = rpl1[j - 1]; + } + rpl1[j] = prev->dpb[i]; + } + + ++n; + } + + if (pic->type == PICTURE_TYPE_B) { + for (i = 0; i < n; i++) { + if (rpl0[i] != rpl1[i]) + break; + } + if (i == n) + FFSWAP(VAAPIEncodePicture*, rpl1[0], rpl1[1]); + } + + if (pic->type == PICTURE_TYPE_P || + pic->type == PICTURE_TYPE_B) { + av_log(avctx, AV_LOG_DEBUG, "Default RefPicList0 for fn=%d/poc=%d:", + hp->frame_num, hp->pic_order_cnt); + for (i = 0; i < n; i++) { + hn = rpl0[i]->priv_data; + av_log(avctx, AV_LOG_DEBUG, " fn=%d/poc=%d", + hn->frame_num, hn->pic_order_cnt); + } + av_log(avctx, AV_LOG_DEBUG, "\n"); + } + if (pic->type == PICTURE_TYPE_B) { + av_log(avctx, AV_LOG_DEBUG, "Default RefPicList1 for fn=%d/poc=%d:", + hp->frame_num, hp->pic_order_cnt); + for (i = 0; i < n; i++) { + hn = rpl1[i]->priv_data; + av_log(avctx, AV_LOG_DEBUG, " fn=%d/poc=%d", + hn->frame_num, hn->pic_order_cnt); + } + av_log(avctx, AV_LOG_DEBUG, "\n"); + } + + *rpl_size = n; +} + static int vaapi_encode_h264_init_slice_params(AVCodecContext *avctx, VAAPIEncodePicture *pic, VAAPIEncodeSlice *slice) { VAAPIEncodeH264Context *priv = avctx->priv_data; + VAAPIEncodeH264Picture *hpic = pic->priv_data; + VAAPIEncodePicture *prev = pic->prev; H264RawSPS *sps = &priv->raw_sps; H264RawPPS *pps = &priv->raw_pps; H264RawSliceHeader *sh = &priv->raw_slice.header; VAEncPictureParameterBufferH264 *vpic = pic->codec_picture_params; VAEncSliceParameterBufferH264 *vslice = slice->codec_slice_params; - int i; + int i, j; if (pic->type == PICTURE_TYPE_IDR) { sh->nal_unit_header.nal_unit_type = H264_NAL_IDR_SLICE; sh->nal_unit_header.nal_ref_idc = 3; } else { sh->nal_unit_header.nal_unit_type = H264_NAL_SLICE; - sh->nal_unit_header.nal_ref_idc = pic->type != PICTURE_TYPE_B; + sh->nal_unit_header.nal_ref_idc = pic->is_reference; } - // Only one slice per frame. - sh->first_mb_in_slice = 0; - sh->slice_type = priv->slice_type; + sh->first_mb_in_slice = slice->block_start; + sh->slice_type = hpic->slice_type; sh->pic_parameter_set_id = pps->pic_parameter_set_id; - sh->frame_num = priv->frame_num; - sh->idr_pic_id = priv->idr_pic_count; - - sh->pic_order_cnt_lsb = priv->pic_order_cnt & + sh->frame_num = hpic->frame_num & + ((1 << (4 + sps->log2_max_frame_num_minus4)) - 1); + sh->idr_pic_id = hpic->idr_pic_id; + sh->pic_order_cnt_lsb = hpic->pic_order_cnt & ((1 << (4 + sps->log2_max_pic_order_cnt_lsb_minus4)) - 1); sh->direct_spatial_mv_pred_flag = 1; @@ -779,9 +859,149 @@ static int vaapi_encode_h264_init_slice_params(AVCodecContext *avctx, else sh->slice_qp_delta = priv->fixed_qp_idr - (pps->pic_init_qp_minus26 + 26); + if (pic->is_reference && pic->type != PICTURE_TYPE_IDR) { + VAAPIEncodePicture *discard_list[MAX_DPB_SIZE]; + int discard = 0, keep = 0; - vslice->macroblock_address = sh->first_mb_in_slice; - vslice->num_macroblocks = priv->mb_width * priv->mb_height; + // Discard everything which is in the DPB of the previous frame but + // not in the DPB of this one. + for (i = 0; i < prev->nb_dpb_pics; i++) { + for (j = 0; j < pic->nb_dpb_pics; j++) { + if (prev->dpb[i] == pic->dpb[j]) + break; + } + if (j == pic->nb_dpb_pics) { + discard_list[discard] = prev->dpb[i]; + ++discard; + } else { + ++keep; + } + } + av_assert0(keep <= priv->dpb_frames); + + if (discard == 0) { + sh->adaptive_ref_pic_marking_mode_flag = 0; + } else { + sh->adaptive_ref_pic_marking_mode_flag = 1; + for (i = 0; i < discard; i++) { + VAAPIEncodeH264Picture *old = discard_list[i]->priv_data; + av_assert0(old->frame_num < hpic->frame_num); + sh->mmco[i].memory_management_control_operation = 1; + sh->mmco[i].difference_of_pic_nums_minus1 = + hpic->frame_num - old->frame_num - 1; + } + sh->mmco[i].memory_management_control_operation = 0; + } + } + + // If the intended references are not the first entries of RefPicListN + // by default, use ref-pic-list-modification to move them there. + if (pic->type == PICTURE_TYPE_P || pic->type == PICTURE_TYPE_B) { + VAAPIEncodePicture *def_l0[MAX_DPB_SIZE], *def_l1[MAX_DPB_SIZE]; + VAAPIEncodeH264Picture *href; + int n; + + vaapi_encode_h264_default_ref_pic_list(avctx, pic, + def_l0, def_l1, &n); + + if (pic->type == PICTURE_TYPE_P) { + int need_rplm = 0; + for (i = 0; i < pic->nb_refs; i++) { + av_assert0(pic->refs[i]); + if (pic->refs[i] != def_l0[i]) + need_rplm = 1; + } + + sh->ref_pic_list_modification_flag_l0 = need_rplm; + if (need_rplm) { + int pic_num = hpic->frame_num; + for (i = 0; i < pic->nb_refs; i++) { + href = pic->refs[i]->priv_data; + av_assert0(href->frame_num != pic_num); + if (href->frame_num < pic_num) { + sh->rplm_l0[i].modification_of_pic_nums_idc = 0; + sh->rplm_l0[i].abs_diff_pic_num_minus1 = + pic_num - href->frame_num - 1; + } else { + sh->rplm_l0[i].modification_of_pic_nums_idc = 1; + sh->rplm_l0[i].abs_diff_pic_num_minus1 = + href->frame_num - pic_num - 1; + } + pic_num = href->frame_num; + } + sh->rplm_l0[i].modification_of_pic_nums_idc = 3; + } + + } else { + int need_rplm_l0 = 0, need_rplm_l1 = 0; + int n0 = 0, n1 = 0; + for (i = 0; i < pic->nb_refs; i++) { + av_assert0(pic->refs[i]); + href = pic->refs[i]->priv_data; + av_assert0(href->pic_order_cnt != hpic->pic_order_cnt); + if (href->pic_order_cnt < hpic->pic_order_cnt) { + if (pic->refs[i] != def_l0[n0]) + need_rplm_l0 = 1; + ++n0; + } else { + if (pic->refs[i] != def_l1[n1]) + need_rplm_l1 = 1; + ++n1; + } + } + + sh->ref_pic_list_modification_flag_l0 = need_rplm_l0; + if (need_rplm_l0) { + int pic_num = hpic->frame_num; + for (i = j = 0; i < pic->nb_refs; i++) { + href = pic->refs[i]->priv_data; + if (href->pic_order_cnt > hpic->pic_order_cnt) + continue; + av_assert0(href->frame_num != pic_num); + if (href->frame_num < pic_num) { + sh->rplm_l0[j].modification_of_pic_nums_idc = 0; + sh->rplm_l0[j].abs_diff_pic_num_minus1 = + pic_num - href->frame_num - 1; + } else { + sh->rplm_l0[j].modification_of_pic_nums_idc = 1; + sh->rplm_l0[j].abs_diff_pic_num_minus1 = + href->frame_num - pic_num - 1; + } + pic_num = href->frame_num; + ++j; + } + av_assert0(j == n0); + sh->rplm_l0[j].modification_of_pic_nums_idc = 3; + } + + sh->ref_pic_list_modification_flag_l1 = need_rplm_l1; + if (need_rplm_l1) { + int pic_num = hpic->frame_num; + for (i = j = 0; i < pic->nb_refs; i++) { + href = pic->refs[i]->priv_data; + if (href->pic_order_cnt < hpic->pic_order_cnt) + continue; + av_assert0(href->frame_num != pic_num); + if (href->frame_num < pic_num) { + sh->rplm_l1[j].modification_of_pic_nums_idc = 0; + sh->rplm_l1[j].abs_diff_pic_num_minus1 = + pic_num - href->frame_num - 1; + } else { + sh->rplm_l1[j].modification_of_pic_nums_idc = 1; + sh->rplm_l1[j].abs_diff_pic_num_minus1 = + href->frame_num - pic_num - 1; + } + pic_num = href->frame_num; + ++j; + } + av_assert0(j == n1); + sh->rplm_l1[j].modification_of_pic_nums_idc = 3; + } + } + } + + vslice->macroblock_address = slice->block_start; + vslice->num_macroblocks = slice->block_size; vslice->macroblock_info = VA_INVALID_ID; @@ -832,33 +1052,34 @@ static av_cold int vaapi_encode_h264_configure(AVCodecContext *avctx) priv->mb_height = FFALIGN(avctx->height, 16) / 16; if (ctx->va_rc_mode == VA_RC_CQP) { - priv->fixed_qp_p = priv->qp; + priv->fixed_qp_p = av_clip(ctx->rc_quality, 1, 51); if (avctx->i_quant_factor > 0.0) - priv->fixed_qp_idr = (int)((priv->fixed_qp_p * avctx->i_quant_factor + - avctx->i_quant_offset) + 0.5); + priv->fixed_qp_idr = + av_clip((avctx->i_quant_factor * priv->fixed_qp_p + + avctx->i_quant_offset) + 0.5, 1, 51); else priv->fixed_qp_idr = priv->fixed_qp_p; if (avctx->b_quant_factor > 0.0) - priv->fixed_qp_b = (int)((priv->fixed_qp_p * avctx->b_quant_factor + - avctx->b_quant_offset) + 0.5); + priv->fixed_qp_b = + av_clip((avctx->b_quant_factor * priv->fixed_qp_p + + avctx->b_quant_offset) + 0.5, 1, 51); else priv->fixed_qp_b = priv->fixed_qp_p; - priv->sei &= ~SEI_TIMING; - av_log(avctx, AV_LOG_DEBUG, "Using fixed QP = " "%d / %d / %d for IDR- / P- / B-frames.\n", priv->fixed_qp_idr, priv->fixed_qp_p, priv->fixed_qp_b); - } else if (ctx->va_rc_mode == VA_RC_CBR || - ctx->va_rc_mode == VA_RC_VBR) { + } else { // These still need to be set for pic_init_qp/slice_qp_delta. priv->fixed_qp_idr = 26; priv->fixed_qp_p = 26; priv->fixed_qp_b = 26; + } - } else { - av_assert0(0 && "Invalid RC mode."); + if (!ctx->rc_mode->hrd) { + // Timing SEI requires a mode respecting HRD parameters. + priv->sei &= ~SEI_TIMING; } if (priv->sei & SEI_IDENTIFIER) { @@ -889,6 +1110,8 @@ static av_cold int vaapi_encode_h264_configure(AVCodecContext *avctx) } } + ctx->roi_quant_range = 51 + 6 * (ctx->profile->depth - 8); + return 0; } @@ -903,8 +1126,17 @@ static const VAAPIEncodeProfile vaapi_encode_h264_profiles[] = { static const VAAPIEncodeType vaapi_encode_type_h264 = { .profiles = vaapi_encode_h264_profiles, + .flags = FLAG_SLICE_CONTROL | + FLAG_B_PICTURES | + FLAG_B_PICTURE_REFERENCES | + FLAG_NON_IDR_KEY_PICTURES, + + .default_quality = 20, + .configure = &vaapi_encode_h264_configure, + .picture_priv_data_size = sizeof(VAAPIEncodeH264Picture), + .sequence_params_size = sizeof(VAEncSequenceParameterBufferH264), .init_sequence_params = &vaapi_encode_h264_init_sequence_params, @@ -978,6 +1210,11 @@ static av_cold int vaapi_encode_h264_init(AVCodecContext *avctx) ctx->surface_width = FFALIGN(avctx->width, 16); ctx->surface_height = FFALIGN(avctx->height, 16); + ctx->slice_block_height = ctx->slice_block_width = 16; + + if (priv->qp > 0) + ctx->explicit_qp = priv->qp; + return ff_vaapi_encode_init(avctx); } @@ -985,6 +1222,7 @@ static av_cold int vaapi_encode_h264_close(AVCodecContext *avctx) { VAAPIEncodeH264Context *priv = avctx->priv_data; + ff_cbs_fragment_free(&priv->current_access_unit); ff_cbs_close(&priv->cbc); av_freep(&priv->sei_identifier_string); @@ -995,9 +1233,10 @@ static av_cold int vaapi_encode_h264_close(AVCodecContext *avctx) #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM) static const AVOption vaapi_encode_h264_options[] = { VAAPI_ENCODE_COMMON_OPTIONS, + VAAPI_ENCODE_RC_OPTIONS, { "qp", "Constant QP (for P-frames; scaled by qfactor/qoffset for I/B)", - OFFSET(qp), AV_OPT_TYPE_INT, { .i64 = 20 }, 0, 52, FLAGS }, + OFFSET(qp), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 52, FLAGS }, { "quality", "Set encode quality (trades off against speed, higher is faster)", OFFSET(quality), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS }, { "coder", "Entropy coder type", @@ -1085,21 +1324,24 @@ static const AVClass vaapi_encode_h264_class = { .version = LIBAVUTIL_VERSION_INT, }; -AVCodec ff_h264_vaapi_encoder = { +const AVCodec ff_h264_vaapi_encoder = { .name = "h264_vaapi", .long_name = NULL_IF_CONFIG_SMALL("H.264/AVC (VAAPI)"), .type = AVMEDIA_TYPE_VIDEO, .id = AV_CODEC_ID_H264, .priv_data_size = sizeof(VAAPIEncodeH264Context), .init = &vaapi_encode_h264_init, - .encode2 = &ff_vaapi_encode2, + .receive_packet = &ff_vaapi_encode_receive_packet, .close = &vaapi_encode_h264_close, .priv_class = &vaapi_encode_h264_class, - .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HARDWARE, + .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HARDWARE | + AV_CODEC_CAP_DR1, + .caps_internal = FF_CODEC_CAP_INIT_CLEANUP, .defaults = vaapi_encode_h264_defaults, .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_VAAPI, AV_PIX_FMT_NONE, }, + .hw_configs = ff_vaapi_encode_hw_configs, .wrapper_name = "vaapi", };