diff --git a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0001-avutil-add-av_buffer_pool_flush.patch b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0001-avutil-add-av_buffer_pool_flush.patch index 188ab13706..6db33f9d39 100644 --- a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0001-avutil-add-av_buffer_pool_flush.patch +++ b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0001-avutil-add-av_buffer_pool_flush.patch @@ -1,7 +1,7 @@ From e6cec3f54693e7e2c10b6b7bc8f72daa6e9a77dc Mon Sep 17 00:00:00 2001 From: Jonas Karlman Date: Mon, 3 Dec 2018 23:48:04 +0100 -Subject: [PATCH] avutil: add av_buffer_pool_flush() +Subject: [PATCH 01/12] avutil: add av_buffer_pool_flush() Signed-off-by: Jonas Karlman --- @@ -49,3 +49,6 @@ index 73b6bd0b14..0678fa4bea 100644 /** * Mark the pool as being available for freeing. It will actually be freed only * once all the allocated buffers associated with the pool are released. Thus it +-- +2.24.0 + diff --git a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0002-Add-common-V4L2-request-API-code.patch b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0002-Add-common-V4L2-request-API-code.patch index 1a9b43e240..3d87974112 100644 --- a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0002-Add-common-V4L2-request-API-code.patch +++ b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0002-Add-common-V4L2-request-API-code.patch @@ -1,16 +1,16 @@ -From b810081f898fc4faec35519c6e7e9d275bf2bbcf Mon Sep 17 00:00:00 2001 +From 457a74f059e5467f7f24f15be1b0e87a34e8cabc Mon Sep 17 00:00:00 2001 From: Jonas Karlman Date: Sat, 15 Dec 2018 22:32:16 +0100 -Subject: [PATCH] Add common V4L2 request API code +Subject: [PATCH 02/12] Add common V4L2 request API code Signed-off-by: Jonas Karlman --- configure | 12 + libavcodec/Makefile | 1 + libavcodec/hwaccel.h | 2 + - libavcodec/v4l2_request.c | 919 ++++++++++++++++++++++++++++++++++++++ - libavcodec/v4l2_request.h | 69 +++ - 5 files changed, 1003 insertions(+) + libavcodec/v4l2_request.c | 943 ++++++++++++++++++++++++++++++++++++++ + libavcodec/v4l2_request.h | 72 +++ + 5 files changed, 1030 insertions(+) create mode 100644 libavcodec/v4l2_request.c create mode 100644 libavcodec/v4l2_request.h @@ -112,10 +112,10 @@ index 3aaa92571c..2eefc91e7e 100644 #endif /* AVCODEC_HWACCEL_H */ diff --git a/libavcodec/v4l2_request.c b/libavcodec/v4l2_request.c new file mode 100644 -index 0000000000..bf9d049eff +index 0000000000..1dabf77689 --- /dev/null +++ b/libavcodec/v4l2_request.c -@@ -0,0 +1,919 @@ +@@ -0,0 +1,943 @@ +/* + * This file is part of FFmpeg. + * @@ -216,7 +216,7 @@ index 0000000000..bf9d049eff + return control.default_value; +} + -+static int v4l2_request_queue_buffer(V4L2RequestContext *ctx, int request_fd, V4L2RequestBuffer *buf) ++static int v4l2_request_queue_buffer(V4L2RequestContext *ctx, int request_fd, V4L2RequestBuffer *buf, uint32_t flags) +{ + struct v4l2_plane planes[1] = {}; + struct v4l2_buffer buffer = { @@ -226,7 +226,7 @@ index 0000000000..bf9d049eff + .timestamp.tv_usec = buf->index + 1, + .bytesused = buf->used, + .request_fd = request_fd, -+ .flags = (request_fd >= 0) ? V4L2_BUF_FLAG_REQUEST_FD : 0, ++ .flags = ((request_fd >= 0) ? V4L2_BUF_FLAG_REQUEST_FD : 0) | flags, + }; + + if (V4L2_TYPE_IS_MULTIPLANAR(buf->buffer.type)) { @@ -308,7 +308,7 @@ index 0000000000..bf9d049eff + return 0; +} + -+int ff_v4l2_request_decode_frame(AVCodecContext *avctx, AVFrame *frame, struct v4l2_ext_control *control, int count) ++static int v4l2_request_queue_decode(AVCodecContext *avctx, AVFrame *frame, struct v4l2_ext_control *control, int count, int first_slice, int last_slice) +{ + V4L2RequestContext *ctx = avctx->internal->hwaccel_priv_data; + V4L2RequestDescriptor *req = (V4L2RequestDescriptor*)frame->data[0]; @@ -316,7 +316,7 @@ index 0000000000..bf9d049eff + fd_set except_fds; + int ret; + -+ av_log(avctx, AV_LOG_DEBUG, "%s: avctx=%p used=%u controls=%d index=%d fd=%d request_fd=%d\n", __func__, avctx, req->output.used, count, req->capture.index, req->capture.fd, req->request_fd); ++ av_log(avctx, AV_LOG_DEBUG, "%s: avctx=%p used=%u controls=%d index=%d fd=%d request_fd=%d first_slice=%d last_slice=%d\n", __func__, avctx, req->output.used, count, req->capture.index, req->capture.fd, req->request_fd, first_slice, last_slice); + + ret = v4l2_request_set_controls(ctx, req->request_fd, control, count); + if (ret < 0) { @@ -326,16 +326,18 @@ index 0000000000..bf9d049eff + + memset(req->output.addr + req->output.used, 0, AV_INPUT_BUFFER_PADDING_SIZE); + -+ ret = v4l2_request_queue_buffer(ctx, req->request_fd, &req->output); ++ ret = v4l2_request_queue_buffer(ctx, req->request_fd, &req->output, last_slice ? 0 : V4L2_BUF_FLAG_M2M_HOLD_CAPTURE_BUF); + if (ret < 0) { + av_log(avctx, AV_LOG_ERROR, "%s: queue output buffer %d failed for request %d, %s (%d)\n", __func__, req->output.index, req->request_fd, strerror(errno), errno); + return -1; + } + -+ ret = v4l2_request_queue_buffer(ctx, -1, &req->capture); -+ if (ret < 0) { -+ av_log(avctx, AV_LOG_ERROR, "%s: queue capture buffer %d failed for request %d, %s (%d)\n", __func__, req->capture.index, req->request_fd, strerror(errno), errno); -+ return -1; ++ if (first_slice) { ++ ret = v4l2_request_queue_buffer(ctx, -1, &req->capture, 0); ++ if (ret < 0) { ++ av_log(avctx, AV_LOG_ERROR, "%s: queue capture buffer %d failed for request %d, %s (%d)\n", __func__, req->capture.index, req->request_fd, strerror(errno), errno); ++ return -1; ++ } + } + + // NOTE: do we need to dequeue when request fails/timeout? @@ -365,10 +367,12 @@ index 0000000000..bf9d049eff + return -1; + } + -+ ret = v4l2_request_dequeue_buffer(ctx, &req->capture); -+ if (ret < 0) { -+ av_log(avctx, AV_LOG_ERROR, "%s: dequeue capture buffer %d failed for request %d, %s (%d)\n", __func__, req->capture.index, req->request_fd, strerror(errno), errno); -+ return -1; ++ if (last_slice) { ++ ret = v4l2_request_dequeue_buffer(ctx, &req->capture); ++ if (ret < 0) { ++ av_log(avctx, AV_LOG_ERROR, "%s: dequeue capture buffer %d failed for request %d, %s (%d)\n", __func__, req->capture.index, req->request_fd, strerror(errno), errno); ++ return -1; ++ } + } + + // TODO: check errors @@ -380,7 +384,10 @@ index 0000000000..bf9d049eff + return -1; + } + -+ return v4l2_request_set_drm_descriptor(req, &ctx->format); ++ if (last_slice) ++ return v4l2_request_set_drm_descriptor(req, &ctx->format); ++ ++ return 0; + +fail: + ret = v4l2_request_dequeue_buffer(ctx, &req->output); @@ -398,6 +405,22 @@ index 0000000000..bf9d049eff + return -1; +} + ++int ff_v4l2_request_decode_slice(AVCodecContext *avctx, AVFrame *frame, struct v4l2_ext_control *control, int count, int first_slice, int last_slice) ++{ ++ V4L2RequestDescriptor *req = (V4L2RequestDescriptor*)frame->data[0]; ++ ++ // fall back to queue each slice as a full frame ++ if ((req->output.capabilities & V4L2_BUF_CAP_SUPPORTS_M2M_HOLD_CAPTURE_BUF) != V4L2_BUF_CAP_SUPPORTS_M2M_HOLD_CAPTURE_BUF) ++ return v4l2_request_queue_decode(avctx, frame, control, count, 1, 1); ++ ++ return v4l2_request_queue_decode(avctx, frame, control, count, first_slice, last_slice); ++} ++ ++int ff_v4l2_request_decode_frame(AVCodecContext *avctx, AVFrame *frame, struct v4l2_ext_control *control, int count) ++{ ++ return v4l2_request_queue_decode(avctx, frame, control, count, 1, 1); ++} ++ +static int v4l2_request_try_format(AVCodecContext *avctx, enum v4l2_buf_type type, uint32_t pixelformat) +{ + V4L2RequestContext *ctx = avctx->internal->hwaccel_priv_data; @@ -866,6 +889,7 @@ index 0000000000..bf9d049eff + } + + buf->index = buffers.index; ++ buf->capabilities = buffers.capabilities; + buf->used = 0; + + buf->buffer.type = type; @@ -1037,10 +1061,10 @@ index 0000000000..bf9d049eff +} diff --git a/libavcodec/v4l2_request.h b/libavcodec/v4l2_request.h new file mode 100644 -index 0000000000..1f45772d8b +index 0000000000..d4146bd4ee --- /dev/null +++ b/libavcodec/v4l2_request.h -@@ -0,0 +1,69 @@ +@@ -0,0 +1,72 @@ +/* + * This file is part of FFmpeg. + * @@ -1081,6 +1105,7 @@ index 0000000000..1f45772d8b + uint32_t height; + uint32_t size; + uint32_t used; ++ uint32_t capabilities; + struct v4l2_buffer buffer; +} V4L2RequestBuffer; + @@ -1101,6 +1126,8 @@ index 0000000000..1f45772d8b + +int ff_v4l2_request_query_control_default_value(AVCodecContext *avctx, uint32_t id); + ++int ff_v4l2_request_decode_slice(AVCodecContext *avctx, AVFrame *frame, struct v4l2_ext_control *control, int count, int first_slice, int last_slice); ++ +int ff_v4l2_request_decode_frame(AVCodecContext *avctx, AVFrame *frame, struct v4l2_ext_control *control, int count); + +int ff_v4l2_request_init(AVCodecContext *avctx, uint32_t pixelformat, uint32_t buffersize, struct v4l2_ext_control *control, int count); @@ -1110,3 +1137,6 @@ index 0000000000..1f45772d8b +int ff_v4l2_request_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx); + +#endif /* AVCODEC_V4L2_REQUEST_H */ +-- +2.24.0 + diff --git a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0003-Add-V4L2-request-API-mpeg2-hwaccel.patch b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0003-Add-V4L2-request-API-mpeg2-hwaccel.patch index fc109896e3..6b8e805364 100644 --- a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0003-Add-V4L2-request-API-mpeg2-hwaccel.patch +++ b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0003-Add-V4L2-request-API-mpeg2-hwaccel.patch @@ -1,7 +1,7 @@ -From f31319e29405004b84f17e30602f77dae671b53e Mon Sep 17 00:00:00 2001 +From d46c4def125a142419db249051fbaa8e743e3e53 Mon Sep 17 00:00:00 2001 From: Jonas Karlman Date: Sat, 15 Dec 2018 22:32:16 +0100 -Subject: [PATCH] Add V4L2 request API mpeg2 hwaccel +Subject: [PATCH 03/12] Add V4L2 request API mpeg2 hwaccel Signed-off-by: Jonas Karlman --- @@ -242,3 +242,6 @@ index 0000000000..782b9c2471 + .frame_params = ff_v4l2_request_frame_params, + .caps_internal = HWACCEL_CAP_ASYNC_SAFE, +}; +-- +2.24.0 + diff --git a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0004-Add-V4L2-request-API-h264-hwaccel.patch b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0004-Add-V4L2-request-API-h264-hwaccel.patch index 917e385a9c..11d6588fe7 100644 --- a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0004-Add-V4L2-request-API-h264-hwaccel.patch +++ b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0004-Add-V4L2-request-API-h264-hwaccel.patch @@ -1,7 +1,7 @@ -From 389f6557715439d5fa974f0cc55e1fa68735ec61 Mon Sep 17 00:00:00 2001 +From fb59440a268d956bffa40604e4422420453b4605 Mon Sep 17 00:00:00 2001 From: Jernej Skrabec Date: Sat, 15 Dec 2018 22:32:16 +0100 -Subject: [PATCH] Add V4L2 request API h264 hwaccel +Subject: [PATCH 04/12] Add V4L2 request API h264 hwaccel Signed-off-by: Jernej Skrabec Signed-off-by: Jonas Karlman @@ -11,8 +11,8 @@ Signed-off-by: Jonas Karlman libavcodec/h264_slice.c | 4 + libavcodec/h264dec.c | 3 + libavcodec/hwaccels.h | 1 + - libavcodec/v4l2_request_h264.c | 420 +++++++++++++++++++++++++++++++++ - 6 files changed, 432 insertions(+) + libavcodec/v4l2_request_h264.c | 443 +++++++++++++++++++++++++++++++++ + 6 files changed, 455 insertions(+) create mode 100644 libavcodec/v4l2_request_h264.c diff --git a/configure b/configure @@ -98,10 +98,10 @@ index ef54de2a3b..003200edea 100644 extern const AVHWAccel ff_h264_videotoolbox_hwaccel; diff --git a/libavcodec/v4l2_request_h264.c b/libavcodec/v4l2_request_h264.c new file mode 100644 -index 0000000000..fb9913922d +index 0000000000..81b3c4b092 --- /dev/null +++ b/libavcodec/v4l2_request_h264.c -@@ -0,0 +1,420 @@ +@@ -0,0 +1,443 @@ +/* + * This file is part of FFmpeg. + * @@ -130,6 +130,7 @@ index 0000000000..fb9913922d + struct v4l2_ctrl_h264_scaling_matrix scaling_matrix; + struct v4l2_ctrl_h264_decode_params decode_params; + struct v4l2_ctrl_h264_slice_params slice_params[16]; ++ int first_slice; +} V4L2RequestControlsH264; + +typedef struct V4L2RequestContextH264 { @@ -297,13 +298,22 @@ index 0000000000..fb9913922d +{ + const H264Context *h = avctx->priv_data; + const PPS *pps = h->ps.pps; ++ const SPS *sps = h->ps.sps; + V4L2RequestControlsH264 *controls = h->cur_pic_ptr->hwaccel_picture_private; + + fill_sps(&controls->sps, h); + fill_pps(&controls->pps, h); + + memcpy(controls->scaling_matrix.scaling_list_4x4, pps->scaling_matrix4, sizeof(controls->scaling_matrix.scaling_list_4x4)); -+ memcpy(controls->scaling_matrix.scaling_list_8x8, pps->scaling_matrix8, sizeof(controls->scaling_matrix.scaling_list_8x8)); ++ memcpy(controls->scaling_matrix.scaling_list_8x8[0], pps->scaling_matrix8[0], sizeof(controls->scaling_matrix.scaling_list_8x8[0])); ++ memcpy(controls->scaling_matrix.scaling_list_8x8[1], pps->scaling_matrix8[3], sizeof(controls->scaling_matrix.scaling_list_8x8[1])); ++ ++ if (sps->chroma_format_idc == 3) { ++ memcpy(controls->scaling_matrix.scaling_list_8x8[2], pps->scaling_matrix8[1], sizeof(controls->scaling_matrix.scaling_list_8x8[2])); ++ memcpy(controls->scaling_matrix.scaling_list_8x8[3], pps->scaling_matrix8[4], sizeof(controls->scaling_matrix.scaling_list_8x8[3])); ++ memcpy(controls->scaling_matrix.scaling_list_8x8[4], pps->scaling_matrix8[2], sizeof(controls->scaling_matrix.scaling_list_8x8[4])); ++ memcpy(controls->scaling_matrix.scaling_list_8x8[5], pps->scaling_matrix8[5], sizeof(controls->scaling_matrix.scaling_list_8x8[5])); ++ } + + controls->decode_params = (struct v4l2_ctrl_h264_decode_params) { + .num_slices = 0, @@ -317,13 +327,16 @@ index 0000000000..fb9913922d + + fill_dpb(&controls->decode_params, h); + ++ controls->first_slice = !FIELD_PICTURE(h) || h->first_field; ++ + return ff_v4l2_request_reset_frame(avctx, h->cur_pic_ptr->f); +} + -+static int v4l2_request_h264_end_frame(AVCodecContext *avctx) ++static int v4l2_request_h264_queue_decode(AVCodecContext *avctx, int last_slice) +{ + const H264Context *h = avctx->priv_data; + V4L2RequestControlsH264 *controls = h->cur_pic_ptr->hwaccel_picture_private; ++ V4L2RequestContextH264 *ctx = avctx->internal->hwaccel_priv_data; + + struct v4l2_ext_control control[] = { + { @@ -353,6 +366,9 @@ index 0000000000..fb9913922d + }, + }; + ++ if (ctx->decode_mode == V4L2_MPEG_VIDEO_H264_DECODE_MODE_SLICE_BASED) ++ return ff_v4l2_request_decode_slice(avctx, h->cur_pic_ptr->f, control, FF_ARRAY_ELEMS(control), controls->first_slice, last_slice); ++ + return ff_v4l2_request_decode_frame(avctx, h->cur_pic_ptr->f, control, FF_ARRAY_ELEMS(control)); +} + @@ -367,12 +383,13 @@ index 0000000000..fb9913922d + int i, ret, count, slice = FFMIN(controls->decode_params.num_slices, 15); + + if (ctx->decode_mode == V4L2_MPEG_VIDEO_H264_DECODE_MODE_SLICE_BASED && slice) { -+ ret = v4l2_request_h264_end_frame(avctx); ++ ret = v4l2_request_h264_queue_decode(avctx, 0); + if (ret) + return ret; + + ff_v4l2_request_reset_frame(avctx, h->cur_pic_ptr->f); + slice = controls->decode_params.num_slices = 0; ++ controls->first_slice = 0; + } + + controls->slice_params[slice] = (struct v4l2_ctrl_h264_slice_params) { @@ -448,6 +465,12 @@ index 0000000000..fb9913922d + return 0; +} + ++static int v4l2_request_h264_end_frame(AVCodecContext *avctx) ++{ ++ const H264Context *h = avctx->priv_data; ++ return v4l2_request_h264_queue_decode(avctx, !FIELD_PICTURE(h) || !h->first_field); ++} ++ +static int v4l2_request_h264_set_controls(AVCodecContext *avctx) +{ + V4L2RequestContextH264 *ctx = avctx->internal->hwaccel_priv_data; @@ -522,3 +545,6 @@ index 0000000000..fb9913922d + .frame_params = ff_v4l2_request_frame_params, + .caps_internal = HWACCEL_CAP_ASYNC_SAFE, +}; +-- +2.24.0 + diff --git a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0005-Add-V4L2-request-API-hevc-hwaccel.patch b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0005-Add-V4L2-request-API-hevc-hwaccel.patch index 17b2063613..e9a806e67e 100644 --- a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0005-Add-V4L2-request-API-hevc-hwaccel.patch +++ b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0005-Add-V4L2-request-API-hevc-hwaccel.patch @@ -1,7 +1,7 @@ -From 0cd5948e34df8acdbc84efc7ce662eee03ce88e3 Mon Sep 17 00:00:00 2001 +From 2511b50434e37a56af86bd38b76a6b5cf4d3117b Mon Sep 17 00:00:00 2001 From: Jernej Skrabec Date: Sat, 15 Dec 2018 22:32:16 +0100 -Subject: [PATCH] Add V4L2 request API hevc hwaccel +Subject: [PATCH 05/12] Add V4L2 request API hevc hwaccel Signed-off-by: Jernej Skrabec Signed-off-by: Jonas Karlman @@ -10,8 +10,8 @@ Signed-off-by: Jonas Karlman libavcodec/Makefile | 1 + libavcodec/hevcdec.c | 10 + libavcodec/hwaccels.h | 1 + - libavcodec/v4l2_request_hevc.c | 391 +++++++++++++++++++++++++++++++++ - 5 files changed, 406 insertions(+) + libavcodec/v4l2_request_hevc.c | 527 +++++++++++++++++++++++++++++++++ + 5 files changed, 542 insertions(+) create mode 100644 libavcodec/v4l2_request_hevc.c diff --git a/configure b/configure @@ -103,10 +103,10 @@ index 003200edea..d183675abe 100644 extern const AVHWAccel ff_hevc_videotoolbox_hwaccel; diff --git a/libavcodec/v4l2_request_hevc.c b/libavcodec/v4l2_request_hevc.c new file mode 100644 -index 0000000000..38969d77fb +index 0000000000..da1fd666d7 --- /dev/null +++ b/libavcodec/v4l2_request_hevc.c -@@ -0,0 +1,391 @@ +@@ -0,0 +1,527 @@ +/* + * This file is part of FFmpeg. + * @@ -133,9 +133,17 @@ index 0000000000..38969d77fb + struct v4l2_ctrl_hevc_sps sps; + struct v4l2_ctrl_hevc_pps pps; + struct v4l2_ctrl_hevc_scaling_matrix scaling_matrix; -+ struct v4l2_ctrl_hevc_slice_params slice_params; ++ struct v4l2_ctrl_hevc_slice_params slice_params[16]; ++ int first_slice; ++ int num_slices; //TODO: this should be in control +} V4L2RequestControlsHEVC; + ++typedef struct V4L2RequestContextHEVC { ++ V4L2RequestContext base; ++ int decode_mode; ++ int start_code; ++} V4L2RequestContextHEVC; ++ +static void v4l2_request_hevc_fill_pred_table(const HEVCContext *h, struct v4l2_hevc_pred_weight_table *table) +{ + int32_t luma_weight_denom, chroma_weight_denom; @@ -233,6 +241,9 @@ index 0000000000..38969d77fb + .bit_size = 0, + .data_bit_offset = get_bits_count(&h->HEVClc->gb), + ++ /* ISO/IEC 23008-2, ITU-T Rec. H.265: General slice segment header */ ++ .slice_segment_addr = sh->slice_segment_addr, ++ + /* ISO/IEC 23008-2, ITU-T Rec. H.265: NAL unit header */ + .nal_unit_type = h->nal_unit_type, + .nuh_temporal_id_plus1 = h->temporal_id + 1, @@ -241,27 +252,18 @@ index 0000000000..38969d77fb + .slice_type = sh->slice_type, + .colour_plane_id = sh->colour_plane_id, + .slice_pic_order_cnt = pic->poc, -+ .slice_sao_luma_flag = sh->slice_sample_adaptive_offset_flag[0], -+ .slice_sao_chroma_flag = sh->slice_sample_adaptive_offset_flag[1], -+ .slice_temporal_mvp_enabled_flag = sh->slice_temporal_mvp_enabled_flag, + .num_ref_idx_l0_active_minus1 = sh->nb_refs[L0] ? sh->nb_refs[L0] - 1 : 0, + .num_ref_idx_l1_active_minus1 = sh->nb_refs[L1] ? sh->nb_refs[L1] - 1 : 0, -+ .mvd_l1_zero_flag = sh->mvd_l1_zero_flag, -+ .cabac_init_flag = sh->cabac_init_flag, -+ .collocated_from_l0_flag = sh->collocated_list == L0 ? 1 : 0, + .collocated_ref_idx = sh->slice_temporal_mvp_enabled_flag ? sh->collocated_ref_idx : 0, + .five_minus_max_num_merge_cand = sh->slice_type == HEVC_SLICE_I ? 0 : 5 - sh->max_num_merge_cand, -+ .use_integer_mv_flag = 0, + .slice_qp_delta = sh->slice_qp_delta, + .slice_cb_qp_offset = sh->slice_cb_qp_offset, + .slice_cr_qp_offset = sh->slice_cr_qp_offset, + .slice_act_y_qp_offset = 0, + .slice_act_cb_qp_offset = 0, + .slice_act_cr_qp_offset = 0, -+ .slice_deblocking_filter_disabled_flag = sh->disable_deblocking_filter_flag, + .slice_beta_offset_div2 = sh->beta_offset / 2, + .slice_tc_offset_div2 = sh->tc_offset / 2, -+ .slice_loop_filter_across_slices_enabled_flag = sh->slice_loop_filter_across_slices_enabled_flag, + + /* ISO/IEC 23008-2, ITU-T Rec. H.265: Picture timing SEI message */ + .pic_struct = h->sei.picture_timing.picture_struct, @@ -270,11 +272,32 @@ index 0000000000..38969d77fb + .num_rps_poc_st_curr_before = h->rps[ST_CURR_BEF].nb_refs, + .num_rps_poc_st_curr_after = h->rps[ST_CURR_AFT].nb_refs, + .num_rps_poc_lt_curr = h->rps[LT_CURR].nb_refs, -+ -+ .slice_segment_addr = sh->slice_segment_addr, -+ .first_slice_segment_in_pic_flag = sh->first_slice_in_pic_flag, + }; + ++ if (sh->slice_sample_adaptive_offset_flag[0]) ++ slice_params->flags |= V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_LUMA; ++ ++ if (sh->slice_sample_adaptive_offset_flag[1]) ++ slice_params->flags |= V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_CHROMA; ++ ++ if (sh->slice_temporal_mvp_enabled_flag) ++ slice_params->flags |= V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_TEMPORAL_MVP_ENABLED; ++ ++ if (sh->mvd_l1_zero_flag) ++ slice_params->flags |= V4L2_HEVC_SLICE_PARAMS_FLAG_MVD_L1_ZERO; ++ ++ if (sh->cabac_init_flag) ++ slice_params->flags |= V4L2_HEVC_SLICE_PARAMS_FLAG_CABAC_INIT; ++ ++ if (sh->collocated_list == L0) ++ slice_params->flags |= V4L2_HEVC_SLICE_PARAMS_FLAG_COLLOCATED_FROM_L0; ++ ++ if (sh->disable_deblocking_filter_flag) ++ slice_params->flags |= V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_DEBLOCKING_FILTER_DISABLED; ++ ++ if (sh->slice_loop_filter_across_slices_enabled_flag) ++ slice_params->flags |= V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_LOOP_FILTER_ACROSS_SLICES_ENABLED; ++ + for (i = 0; i < FF_ARRAY_ELEMS(h->DPB); i++) { + const HEVCFrame *frame = &h->DPB[i]; + if (frame != pic && (frame->flags & (HEVC_FRAME_FLAG_LONG_REF | HEVC_FRAME_FLAG_SHORT_REF))) { @@ -332,7 +355,6 @@ index 0000000000..38969d77fb + /* ISO/IEC 23008-2, ITU-T Rec. H.265: Sequence parameter set */ + controls->sps = (struct v4l2_ctrl_hevc_sps) { + .chroma_format_idc = sps->chroma_format_idc, -+ .separate_colour_plane_flag = sps->separate_colour_plane_flag, + .pic_width_in_luma_samples = sps->width, + .pic_height_in_luma_samples = sps->height, + .bit_depth_luma_minus8 = sps->bit_depth - 8, @@ -347,22 +369,41 @@ index 0000000000..38969d77fb + .log2_diff_max_min_luma_transform_block_size = sps->log2_max_trafo_size - sps->log2_min_tb_size, + .max_transform_hierarchy_depth_inter = sps->max_transform_hierarchy_depth_inter, + .max_transform_hierarchy_depth_intra = sps->max_transform_hierarchy_depth_intra, -+ .scaling_list_enabled_flag = sps->scaling_list_enable_flag, -+ .amp_enabled_flag = sps->amp_enabled_flag, -+ .sample_adaptive_offset_enabled_flag = sps->sao_enabled, -+ .pcm_enabled_flag = sps->pcm_enabled_flag, + .pcm_sample_bit_depth_luma_minus1 = sps->pcm.bit_depth - 1, + .pcm_sample_bit_depth_chroma_minus1 = sps->pcm.bit_depth_chroma - 1, + .log2_min_pcm_luma_coding_block_size_minus3 = sps->pcm.log2_min_pcm_cb_size - 3, + .log2_diff_max_min_pcm_luma_coding_block_size = sps->pcm.log2_max_pcm_cb_size - sps->pcm.log2_min_pcm_cb_size, -+ .pcm_loop_filter_disabled_flag = sps->pcm.loop_filter_disable_flag, + .num_short_term_ref_pic_sets = sps->nb_st_rps, -+ .long_term_ref_pics_present_flag = sps->long_term_ref_pics_present_flag, + .num_long_term_ref_pics_sps = sps->num_long_term_ref_pics_sps, -+ .sps_temporal_mvp_enabled_flag = sps->sps_temporal_mvp_enabled_flag, -+ .strong_intra_smoothing_enabled_flag = sps->sps_strong_intra_smoothing_enable_flag, + }; + ++ if (sps->separate_colour_plane_flag) ++ controls->sps.flags |= V4L2_HEVC_SPS_FLAG_SEPARATE_COLOUR_PLANE; ++ ++ if (sps->scaling_list_enable_flag) ++ controls->sps.flags |= V4L2_HEVC_SPS_FLAG_SCALING_LIST_ENABLED; ++ ++ if (sps->amp_enabled_flag) ++ controls->sps.flags |= V4L2_HEVC_SPS_FLAG_AMP_ENABLED; ++ ++ if (sps->sao_enabled) ++ controls->sps.flags |= V4L2_HEVC_SPS_FLAG_SAMPLE_ADAPTIVE_OFFSET; ++ ++ if (sps->pcm_enabled_flag) ++ controls->sps.flags |= V4L2_HEVC_SPS_FLAG_PCM_ENABLED; ++ ++ if (sps->pcm.loop_filter_disable_flag) ++ controls->sps.flags |= V4L2_HEVC_SPS_FLAG_PCM_LOOP_FILTER_DISABLED; ++ ++ if (sps->long_term_ref_pics_present_flag) ++ controls->sps.flags |= V4L2_HEVC_SPS_FLAG_LONG_TERM_REF_PICS_PRESENT; ++ ++ if (sps->sps_temporal_mvp_enabled_flag) ++ controls->sps.flags |= V4L2_HEVC_SPS_FLAG_SPS_TEMPORAL_MVP_ENABLED; ++ ++ if (sps->sps_strong_intra_smoothing_enable_flag) ++ controls->sps.flags |= V4L2_HEVC_SPS_FLAG_STRONG_INTRA_SMOOTHING_ENABLED; ++ + if (sl) { + for (int i = 0; i < 6; i++) { + for (int j = 0; j < 16; j++) @@ -381,41 +422,79 @@ index 0000000000..38969d77fb + + /* ISO/IEC 23008-2, ITU-T Rec. H.265: Picture parameter set */ + controls->pps = (struct v4l2_ctrl_hevc_pps) { -+ .dependent_slice_segment_flag = pps->dependent_slice_segments_enabled_flag, -+ .output_flag_present_flag = pps->output_flag_present_flag, + .num_extra_slice_header_bits = pps->num_extra_slice_header_bits, -+ .sign_data_hiding_enabled_flag = pps->sign_data_hiding_flag, -+ .cabac_init_present_flag = pps->cabac_init_present_flag, + .init_qp_minus26 = pps->pic_init_qp_minus26, -+ .constrained_intra_pred_flag = pps->constrained_intra_pred_flag, -+ .transform_skip_enabled_flag = pps->transform_skip_enabled_flag, -+ .cu_qp_delta_enabled_flag = pps->cu_qp_delta_enabled_flag, + .diff_cu_qp_delta_depth = pps->diff_cu_qp_delta_depth, + .pps_cb_qp_offset = pps->cb_qp_offset, + .pps_cr_qp_offset = pps->cr_qp_offset, -+ .pps_slice_chroma_qp_offsets_present_flag = pps->pic_slice_level_chroma_qp_offsets_present_flag, -+ .weighted_pred_flag = pps->weighted_pred_flag, -+ .weighted_bipred_flag = pps->weighted_bipred_flag, -+ .transquant_bypass_enabled_flag = pps->transquant_bypass_enable_flag, -+ .tiles_enabled_flag = pps->tiles_enabled_flag, -+ .entropy_coding_sync_enabled_flag = pps->entropy_coding_sync_enabled_flag, -+ .loop_filter_across_tiles_enabled_flag = pps->loop_filter_across_tiles_enabled_flag, -+ .pps_loop_filter_across_slices_enabled_flag = pps->seq_loop_filter_across_slices_enabled_flag, -+ .deblocking_filter_override_enabled_flag = pps->deblocking_filter_override_enabled_flag, -+ .pps_disable_deblocking_filter_flag = pps->disable_dbf, + .pps_beta_offset_div2 = pps->beta_offset / 2, + .pps_tc_offset_div2 = pps->tc_offset / 2, -+ .lists_modification_present_flag = pps->lists_modification_present_flag, + .log2_parallel_merge_level_minus2 = pps->log2_parallel_merge_level - 2, -+ .slice_segment_header_extension_present_flag = pps->slice_header_extension_present_flag, -+ .scaling_list_enable_flag = pps->scaling_list_data_present_flag, // pps_scaling_list_data_present_flag + }; + ++ if (pps->dependent_slice_segments_enabled_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_DEPENDENT_SLICE_SEGMENT; ++ ++ if (pps->output_flag_present_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_OUTPUT_FLAG_PRESENT; ++ ++ if (pps->sign_data_hiding_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_SIGN_DATA_HIDING_ENABLED; ++ ++ if (pps->cabac_init_present_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_CABAC_INIT_PRESENT; ++ ++ if (pps->constrained_intra_pred_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_CONSTRAINED_INTRA_PRED; ++ ++ if (pps->transform_skip_enabled_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_TRANSFORM_SKIP_ENABLED; ++ ++ if (pps->cu_qp_delta_enabled_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_CU_QP_DELTA_ENABLED; ++ ++ if (pps->pic_slice_level_chroma_qp_offsets_present_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT; ++ ++ if (pps->weighted_pred_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_WEIGHTED_PRED; ++ ++ if (pps->weighted_bipred_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_WEIGHTED_BIPRED; ++ ++ if (pps->transquant_bypass_enable_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_TRANSQUANT_BYPASS_ENABLED; ++ ++ if (pps->tiles_enabled_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_TILES_ENABLED; ++ ++ if (pps->entropy_coding_sync_enabled_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_ENTROPY_CODING_SYNC_ENABLED; ++ ++ if (pps->loop_filter_across_tiles_enabled_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_LOOP_FILTER_ACROSS_TILES_ENABLED; ++ ++ if (pps->seq_loop_filter_across_slices_enabled_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_PPS_LOOP_FILTER_ACROSS_SLICES_ENABLED; ++ ++ if (pps->deblocking_filter_override_enabled_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_DEBLOCKING_FILTER_OVERRIDE_ENABLED; ++ ++ if (pps->disable_dbf) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_PPS_DISABLE_DEBLOCKING_FILTER; ++ ++ if (pps->lists_modification_present_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_LISTS_MODIFICATION_PRESENT; ++ ++ if (pps->slice_header_extension_present_flag) ++ controls->pps.flags |= V4L2_HEVC_PPS_FLAG_SLICE_SEGMENT_HEADER_EXTENSION_PRESENT; ++ + if (pps->tiles_enabled_flag) { + controls->pps.num_tile_columns_minus1 = pps->num_tile_columns - 1; + controls->pps.num_tile_rows_minus1 = pps->num_tile_rows - 1; + -+ av_log(avctx, AV_LOG_DEBUG, "%s: avctx=%p tiles_enabled_flag=%d num_tile_columns=%d num_tile_rows=%d\n", __func__, avctx, pps->tiles_enabled_flag, pps->num_tile_columns, pps->num_tile_rows); ++ av_log(avctx, AV_LOG_DEBUG, "%s: avctx=%p tiles_enabled_flag=%d num_tile_columns=%d num_tile_rows=%d\n", ++ __func__, avctx, pps->tiles_enabled_flag, pps->num_tile_columns, pps->num_tile_rows); + + for (int i = 0; i < pps->num_tile_columns; i++) + controls->pps.column_width_minus1[i] = pps->column_width[i] - 1; @@ -424,14 +503,17 @@ index 0000000000..38969d77fb + controls->pps.row_height_minus1[i] = pps->row_height[i] - 1; + } + ++ controls->first_slice = 1; ++ controls->num_slices = 0; ++ + return ff_v4l2_request_reset_frame(avctx, h->ref->frame); +} + -+static int v4l2_request_hevc_end_frame(AVCodecContext *avctx) ++static int v4l2_request_hevc_queue_decode(AVCodecContext *avctx, int last_slice) +{ + const HEVCContext *h = avctx->priv_data; + V4L2RequestControlsHEVC *controls = h->ref->hwaccel_picture_private; -+ V4L2RequestDescriptor *req = (V4L2RequestDescriptor*)h->ref->frame->data[0]; ++ V4L2RequestContextHEVC *ctx = avctx->internal->hwaccel_priv_data; + + struct v4l2_ext_control control[] = { + { @@ -452,35 +534,89 @@ index 0000000000..38969d77fb + { + .id = V4L2_CID_MPEG_VIDEO_HEVC_SLICE_PARAMS, + .ptr = &controls->slice_params, -+ .size = sizeof(controls->slice_params), ++ .size = sizeof(controls->slice_params[0]) * FFMIN(controls->num_slices, 16), + }, + }; + -+ controls->slice_params.bit_size = req->output.used * 8; ++ if (ctx->decode_mode == V4L2_MPEG_VIDEO_HEVC_DECODE_MODE_SLICE_BASED) ++ return ff_v4l2_request_decode_slice(avctx, h->ref->frame, control, FF_ARRAY_ELEMS(control), controls->first_slice, last_slice); + + return ff_v4l2_request_decode_frame(avctx, h->ref->frame, control, FF_ARRAY_ELEMS(control)); +} + ++static int v4l2_request_hevc_end_frame(AVCodecContext *avctx) ++{ ++ return v4l2_request_hevc_queue_decode(avctx, 1); ++} ++ +static int v4l2_request_hevc_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size) +{ + const HEVCContext *h = avctx->priv_data; + V4L2RequestControlsHEVC *controls = h->ref->hwaccel_picture_private; + V4L2RequestDescriptor *req = (V4L2RequestDescriptor*)h->ref->frame->data[0]; ++ V4L2RequestContextHEVC *ctx = avctx->internal->hwaccel_priv_data; ++ int ret, slice = FFMIN(controls->num_slices, 15); + -+ // HACK: trigger decode per slice -+ if (req->output.used) { -+ v4l2_request_hevc_end_frame(avctx); -+ ff_v4l2_request_reset_frame(avctx, h->ref->frame); ++ if (ctx->decode_mode == V4L2_MPEG_VIDEO_HEVC_DECODE_MODE_SLICE_BASED && slice) { ++ ret = v4l2_request_hevc_queue_decode(avctx, 0); ++ if (ret) ++ return ret; ++ ++ ff_v4l2_request_reset_frame(avctx, h->ref->frame); ++ slice = controls->num_slices = 0; ++ controls->first_slice = 0; + } + -+ v4l2_request_hevc_fill_slice_params(h, &controls->slice_params); ++ v4l2_request_hevc_fill_slice_params(h, &controls->slice_params[slice]); + -+ return ff_v4l2_request_append_output_buffer(avctx, h->ref->frame, buffer, size); ++ ret = ff_v4l2_request_append_output_buffer(avctx, h->ref->frame, buffer, size); ++ if (ret) ++ return ret; ++ ++ controls->slice_params[slice].bit_size = req->output.used * 8; //FIXME ++ controls->num_slices++; ++ ++ return 0; ++} ++ ++static int v4l2_request_hevc_set_controls(AVCodecContext *avctx) ++{ ++ V4L2RequestContextHEVC *ctx = avctx->internal->hwaccel_priv_data; ++ ++ struct v4l2_ext_control control[] = { ++ { .id = V4L2_CID_MPEG_VIDEO_HEVC_DECODE_MODE, }, ++ { .id = V4L2_CID_MPEG_VIDEO_HEVC_START_CODE, }, ++ }; ++ ++ ctx->decode_mode = ff_v4l2_request_query_control_default_value(avctx, V4L2_CID_MPEG_VIDEO_HEVC_DECODE_MODE); ++ if (ctx->decode_mode != V4L2_MPEG_VIDEO_HEVC_DECODE_MODE_SLICE_BASED && ++ ctx->decode_mode != V4L2_MPEG_VIDEO_HEVC_DECODE_MODE_FRAME_BASED) { ++ av_log(avctx, AV_LOG_ERROR, "%s: unsupported decode mode, %d\n", __func__, ctx->decode_mode); ++ return AVERROR(EINVAL); ++ } ++ ++ ctx->start_code = ff_v4l2_request_query_control_default_value(avctx, V4L2_CID_MPEG_VIDEO_HEVC_START_CODE); ++ if (ctx->start_code != V4L2_MPEG_VIDEO_HEVC_START_CODE_NONE && ++ ctx->start_code != V4L2_MPEG_VIDEO_HEVC_START_CODE_ANNEX_B) { ++ av_log(avctx, AV_LOG_ERROR, "%s: unsupported start code, %d\n", __func__, ctx->start_code); ++ return AVERROR(EINVAL); ++ } ++ ++ control[0].value = ctx->decode_mode; ++ control[1].value = ctx->start_code; ++ ++ return ff_v4l2_request_set_controls(avctx, control, FF_ARRAY_ELEMS(control)); +} + +static int v4l2_request_hevc_init(AVCodecContext *avctx) +{ -+ return ff_v4l2_request_init(avctx, V4L2_PIX_FMT_HEVC_SLICE, 3 * 1024 * 1024, NULL, 0); ++ int ret; ++ ++ ret = ff_v4l2_request_init(avctx, V4L2_PIX_FMT_HEVC_SLICE, 3 * 1024 * 1024, NULL, 0); ++ if (ret) ++ return ret; ++ ++ return v4l2_request_hevc_set_controls(avctx); +} + +const AVHWAccel ff_hevc_v4l2request_hwaccel = { @@ -494,7 +630,10 @@ index 0000000000..38969d77fb + .frame_priv_data_size = sizeof(V4L2RequestControlsHEVC), + .init = v4l2_request_hevc_init, + .uninit = ff_v4l2_request_uninit, -+ .priv_data_size = sizeof(V4L2RequestContext), ++ .priv_data_size = sizeof(V4L2RequestContextHEVC), + .frame_params = ff_v4l2_request_frame_params, + .caps_internal = HWACCEL_CAP_ASYNC_SAFE, +}; +-- +2.24.0 + diff --git a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0006-Add-V4L2-request-API-vp8-hwaccel.patch b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0006-Add-V4L2-request-API-vp8-hwaccel.patch index ffcf5ceeac..574262453f 100644 --- a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0006-Add-V4L2-request-API-vp8-hwaccel.patch +++ b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0006-Add-V4L2-request-API-vp8-hwaccel.patch @@ -1,7 +1,7 @@ -From 2537bdd10973c0fc3f757cab01fd71dd0ef6b1e1 Mon Sep 17 00:00:00 2001 +From 13e487a5da1f64901391b99aa094a697fd2889aa Mon Sep 17 00:00:00 2001 From: Boris Brezillon Date: Wed, 22 May 2019 14:46:58 +0200 -Subject: [PATCH] Add V4L2 request API vp8 hwaccel +Subject: [PATCH 06/12] Add V4L2 request API vp8 hwaccel Need to fix the STREAMOFF/STREAMON issue in a proper way. @@ -280,3 +280,6 @@ index 62b9f8bc2d..55966b9d56 100644 #endif NULL }, +-- +2.24.0 + diff --git a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0007-Add-and-use-private-linux-headers-for-V4L2-request-A.patch b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0007-Add-and-use-private-linux-headers-for-V4L2-request-A.patch index ccd7670c68..c0eb659609 100644 --- a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0007-Add-and-use-private-linux-headers-for-V4L2-request-A.patch +++ b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0007-Add-and-use-private-linux-headers-for-V4L2-request-A.patch @@ -1,20 +1,21 @@ -From be39d2e3e5228cdc2cf355d85f5566205f6cb65d Mon Sep 17 00:00:00 2001 +From 23e7417b7ceb66f2ff4a98da5b1785d24994f865 Mon Sep 17 00:00:00 2001 From: Jernej Skrabec Date: Thu, 14 Feb 2019 23:20:05 +0100 -Subject: [PATCH] Add and use private linux headers for V4L2 request API ctrls +Subject: [PATCH 07/12] Add and use private linux headers for V4L2 request API + ctrls Signed-off-by: Jernej Skrabec --- configure | 6 +- - libavcodec/h264-ctrls.h | 210 ++++++++++++++++++++++++++++++++ - libavcodec/hevc-ctrls.h | 203 ++++++++++++++++++++++++++++++ - libavcodec/mpeg2-ctrls.h | 82 +++++++++++++ + libavcodec/h264-ctrls.h | 210 +++++++++++++++++++++++++++++ + libavcodec/hevc-ctrls.h | 229 ++++++++++++++++++++++++++++++++ + libavcodec/mpeg2-ctrls.h | 82 ++++++++++++ libavcodec/v4l2_request_h264.c | 1 + libavcodec/v4l2_request_hevc.c | 1 + libavcodec/v4l2_request_mpeg2.c | 1 + libavcodec/v4l2_request_vp8.c | 1 + - libavcodec/vp8-ctrls.h | 112 +++++++++++++++++ - 9 files changed, 614 insertions(+), 3 deletions(-) + libavcodec/vp8-ctrls.h | 112 ++++++++++++++++ + 9 files changed, 640 insertions(+), 3 deletions(-) create mode 100644 libavcodec/h264-ctrls.h create mode 100644 libavcodec/hevc-ctrls.h create mode 100644 libavcodec/mpeg2-ctrls.h @@ -269,10 +270,10 @@ index 0000000000..e877bf1d53 +#endif diff --git a/libavcodec/hevc-ctrls.h b/libavcodec/hevc-ctrls.h new file mode 100644 -index 0000000000..eee4479c7a +index 0000000000..d1b094c8aa --- /dev/null +++ b/libavcodec/hevc-ctrls.h -@@ -0,0 +1,203 @@ +@@ -0,0 +1,229 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * These are the HEVC state controls for use with stateless HEVC @@ -295,6 +296,8 @@ index 0000000000..eee4479c7a +#define V4L2_CID_MPEG_VIDEO_HEVC_PPS (V4L2_CID_MPEG_BASE + 1009) +#define V4L2_CID_MPEG_VIDEO_HEVC_SLICE_PARAMS (V4L2_CID_MPEG_BASE + 1010) +#define V4L2_CID_MPEG_VIDEO_HEVC_SCALING_MATRIX (V4L2_CID_MPEG_BASE + 1011) ++#define V4L2_CID_MPEG_VIDEO_HEVC_DECODE_MODE (V4L2_CID_MPEG_BASE + 1015) ++#define V4L2_CID_MPEG_VIDEO_HEVC_START_CODE (V4L2_CID_MPEG_BASE + 1016) + +/* enum v4l2_ctrl_type type values */ +#define V4L2_CTRL_TYPE_HEVC_SPS 0x0120 @@ -302,15 +305,33 @@ index 0000000000..eee4479c7a +#define V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS 0x0122 +#define V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX 0x0123 + ++enum v4l2_mpeg_video_hevc_decode_mode { ++ V4L2_MPEG_VIDEO_HEVC_DECODE_MODE_SLICE_BASED, ++ V4L2_MPEG_VIDEO_HEVC_DECODE_MODE_FRAME_BASED, ++}; ++ ++enum v4l2_mpeg_video_hevc_start_code { ++ V4L2_MPEG_VIDEO_HEVC_START_CODE_NONE, ++ V4L2_MPEG_VIDEO_HEVC_START_CODE_ANNEX_B, ++}; ++ +#define V4L2_HEVC_SLICE_TYPE_B 0 +#define V4L2_HEVC_SLICE_TYPE_P 1 +#define V4L2_HEVC_SLICE_TYPE_I 2 + ++#define V4L2_HEVC_SPS_FLAG_SEPARATE_COLOUR_PLANE (1ULL << 0) ++#define V4L2_HEVC_SPS_FLAG_SCALING_LIST_ENABLED (1ULL << 1) ++#define V4L2_HEVC_SPS_FLAG_AMP_ENABLED (1ULL << 2) ++#define V4L2_HEVC_SPS_FLAG_SAMPLE_ADAPTIVE_OFFSET (1ULL << 3) ++#define V4L2_HEVC_SPS_FLAG_PCM_ENABLED (1ULL << 4) ++#define V4L2_HEVC_SPS_FLAG_PCM_LOOP_FILTER_DISABLED (1ULL << 5) ++#define V4L2_HEVC_SPS_FLAG_LONG_TERM_REF_PICS_PRESENT (1ULL << 6) ++#define V4L2_HEVC_SPS_FLAG_SPS_TEMPORAL_MVP_ENABLED (1ULL << 7) ++#define V4L2_HEVC_SPS_FLAG_STRONG_INTRA_SMOOTHING_ENABLED (1ULL << 8) ++ +/* The controls are not stable at the moment and will likely be reworked. */ +struct v4l2_ctrl_hevc_sps { + /* ISO/IEC 23008-2, ITU-T Rec. H.265: Sequence parameter set */ -+ __u8 chroma_format_idc; -+ __u8 separate_colour_plane_flag; + __u16 pic_width_in_luma_samples; + __u16 pic_height_in_luma_samples; + __u8 bit_depth_luma_minus8; @@ -325,56 +346,56 @@ index 0000000000..eee4479c7a + __u8 log2_diff_max_min_luma_transform_block_size; + __u8 max_transform_hierarchy_depth_inter; + __u8 max_transform_hierarchy_depth_intra; -+ __u8 scaling_list_enabled_flag; -+ __u8 amp_enabled_flag; -+ __u8 sample_adaptive_offset_enabled_flag; -+ __u8 pcm_enabled_flag; + __u8 pcm_sample_bit_depth_luma_minus1; + __u8 pcm_sample_bit_depth_chroma_minus1; + __u8 log2_min_pcm_luma_coding_block_size_minus3; + __u8 log2_diff_max_min_pcm_luma_coding_block_size; -+ __u8 pcm_loop_filter_disabled_flag; + __u8 num_short_term_ref_pic_sets; -+ __u8 long_term_ref_pics_present_flag; + __u8 num_long_term_ref_pics_sps; -+ __u8 sps_temporal_mvp_enabled_flag; -+ __u8 strong_intra_smoothing_enabled_flag; ++ __u8 chroma_format_idc; ++ ++ __u8 padding; ++ ++ __u64 flags; +}; + ++#define V4L2_HEVC_PPS_FLAG_DEPENDENT_SLICE_SEGMENT (1ULL << 0) ++#define V4L2_HEVC_PPS_FLAG_OUTPUT_FLAG_PRESENT (1ULL << 1) ++#define V4L2_HEVC_PPS_FLAG_SIGN_DATA_HIDING_ENABLED (1ULL << 2) ++#define V4L2_HEVC_PPS_FLAG_CABAC_INIT_PRESENT (1ULL << 3) ++#define V4L2_HEVC_PPS_FLAG_CONSTRAINED_INTRA_PRED (1ULL << 4) ++#define V4L2_HEVC_PPS_FLAG_TRANSFORM_SKIP_ENABLED (1ULL << 5) ++#define V4L2_HEVC_PPS_FLAG_CU_QP_DELTA_ENABLED (1ULL << 6) ++#define V4L2_HEVC_PPS_FLAG_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT (1ULL << 7) ++#define V4L2_HEVC_PPS_FLAG_WEIGHTED_PRED (1ULL << 8) ++#define V4L2_HEVC_PPS_FLAG_WEIGHTED_BIPRED (1ULL << 9) ++#define V4L2_HEVC_PPS_FLAG_TRANSQUANT_BYPASS_ENABLED (1ULL << 10) ++#define V4L2_HEVC_PPS_FLAG_TILES_ENABLED (1ULL << 11) ++#define V4L2_HEVC_PPS_FLAG_ENTROPY_CODING_SYNC_ENABLED (1ULL << 12) ++#define V4L2_HEVC_PPS_FLAG_LOOP_FILTER_ACROSS_TILES_ENABLED (1ULL << 13) ++#define V4L2_HEVC_PPS_FLAG_PPS_LOOP_FILTER_ACROSS_SLICES_ENABLED (1ULL << 14) ++#define V4L2_HEVC_PPS_FLAG_DEBLOCKING_FILTER_OVERRIDE_ENABLED (1ULL << 15) ++#define V4L2_HEVC_PPS_FLAG_PPS_DISABLE_DEBLOCKING_FILTER (1ULL << 16) ++#define V4L2_HEVC_PPS_FLAG_LISTS_MODIFICATION_PRESENT (1ULL << 17) ++#define V4L2_HEVC_PPS_FLAG_SLICE_SEGMENT_HEADER_EXTENSION_PRESENT (1ULL << 18) ++ +struct v4l2_ctrl_hevc_pps { + /* ISO/IEC 23008-2, ITU-T Rec. H.265: Picture parameter set */ -+ __u8 dependent_slice_segment_flag; -+ __u8 output_flag_present_flag; + __u8 num_extra_slice_header_bits; -+ __u8 sign_data_hiding_enabled_flag; -+ __u8 cabac_init_present_flag; + __s8 init_qp_minus26; -+ __u8 constrained_intra_pred_flag; -+ __u8 transform_skip_enabled_flag; -+ __u8 cu_qp_delta_enabled_flag; + __u8 diff_cu_qp_delta_depth; + __s8 pps_cb_qp_offset; + __s8 pps_cr_qp_offset; -+ __u8 pps_slice_chroma_qp_offsets_present_flag; -+ __u8 weighted_pred_flag; -+ __u8 weighted_bipred_flag; -+ __u8 transquant_bypass_enabled_flag; -+ __u8 tiles_enabled_flag; -+ __u8 entropy_coding_sync_enabled_flag; + __u8 num_tile_columns_minus1; + __u8 num_tile_rows_minus1; + __u8 column_width_minus1[20]; + __u8 row_height_minus1[22]; -+ __u8 loop_filter_across_tiles_enabled_flag; -+ __u8 pps_loop_filter_across_slices_enabled_flag; -+ __u8 deblocking_filter_override_enabled_flag; -+ __u8 pps_disable_deblocking_filter_flag; + __s8 pps_beta_offset_div2; + __s8 pps_tc_offset_div2; -+ __u8 lists_modification_present_flag; + __u8 log2_parallel_merge_level_minus2; -+ __u8 slice_segment_header_extension_present_flag; -+ __u8 scaling_list_enable_flag; ++ ++ __u8 padding[4]; ++ __u64 flags; +}; + +#define V4L2_HEVC_DPB_ENTRY_RPS_ST_CURR_BEFORE 0x01 @@ -392,9 +413,6 @@ index 0000000000..eee4479c7a +}; + +struct v4l2_hevc_pred_weight_table { -+ __u8 luma_log2_weight_denom; -+ __s8 delta_chroma_log2_weight_denom; -+ + __s8 delta_luma_weight_l0[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __s8 luma_offset_l0[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __s8 delta_chroma_weight_l0[V4L2_HEVC_DPB_ENTRIES_NUM_MAX][2]; @@ -405,13 +423,30 @@ index 0000000000..eee4479c7a + __s8 delta_chroma_weight_l1[V4L2_HEVC_DPB_ENTRIES_NUM_MAX][2]; + __s8 chroma_offset_l1[V4L2_HEVC_DPB_ENTRIES_NUM_MAX][2]; + -+ __u8 padding[2]; ++ __u8 padding[6]; ++ ++ __u8 luma_log2_weight_denom; ++ __s8 delta_chroma_log2_weight_denom; +}; + ++#define V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_LUMA (1ULL << 0) ++#define V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_CHROMA (1ULL << 1) ++#define V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_TEMPORAL_MVP_ENABLED (1ULL << 2) ++#define V4L2_HEVC_SLICE_PARAMS_FLAG_MVD_L1_ZERO (1ULL << 3) ++#define V4L2_HEVC_SLICE_PARAMS_FLAG_CABAC_INIT (1ULL << 4) ++#define V4L2_HEVC_SLICE_PARAMS_FLAG_COLLOCATED_FROM_L0 (1ULL << 5) ++#define V4L2_HEVC_SLICE_PARAMS_FLAG_USE_INTEGER_MV (1ULL << 6) ++#define V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_DEBLOCKING_FILTER_DISABLED (1ULL << 7) ++#define V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_LOOP_FILTER_ACROSS_SLICES_ENABLED (1ULL << 8) ++ +struct v4l2_ctrl_hevc_slice_params { + __u32 bit_size; + __u32 data_bit_offset; + ++ /* ISO/IEC 23008-2, ITU-T Rec. H.265: General slice segment header */ ++ __u32 slice_segment_addr; ++ __u32 num_entry_point_offsets; ++ + /* ISO/IEC 23008-2, ITU-T Rec. H.265: NAL unit header */ + __u8 nal_unit_type; + __u8 nuh_temporal_id_plus1; @@ -420,33 +455,23 @@ index 0000000000..eee4479c7a + __u8 slice_type; + __u8 colour_plane_id; + __u16 slice_pic_order_cnt; -+ __u8 slice_sao_luma_flag; -+ __u8 slice_sao_chroma_flag; -+ __u8 slice_temporal_mvp_enabled_flag; + __u8 num_ref_idx_l0_active_minus1; + __u8 num_ref_idx_l1_active_minus1; -+ __u8 mvd_l1_zero_flag; -+ __u8 cabac_init_flag; -+ __u8 collocated_from_l0_flag; + __u8 collocated_ref_idx; + __u8 five_minus_max_num_merge_cand; -+ __u8 use_integer_mv_flag; + __s8 slice_qp_delta; + __s8 slice_cb_qp_offset; + __s8 slice_cr_qp_offset; + __s8 slice_act_y_qp_offset; + __s8 slice_act_cb_qp_offset; + __s8 slice_act_cr_qp_offset; -+ __u8 slice_deblocking_filter_disabled_flag; + __s8 slice_beta_offset_div2; + __s8 slice_tc_offset_div2; -+ __u8 slice_loop_filter_across_slices_enabled_flag; + + /* ISO/IEC 23008-2, ITU-T Rec. H.265: Picture timing SEI message */ + __u8 pic_struct; + + /* ISO/IEC 23008-2, ITU-T Rec. H.265: General slice segment header */ -+ struct v4l2_hevc_dpb_entry dpb[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 num_active_dpb_entries; + __u8 ref_idx_l0[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 ref_idx_l1[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; @@ -455,15 +480,17 @@ index 0000000000..eee4479c7a + __u8 num_rps_poc_st_curr_after; + __u8 num_rps_poc_lt_curr; + ++ __u8 padding; ++ ++ __u32 entry_point_offset_minus1[256]; ++ ++ /* ISO/IEC 23008-2, ITU-T Rec. H.265: General slice segment header */ ++ struct v4l2_hevc_dpb_entry dpb[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; ++ + /* ISO/IEC 23008-2, ITU-T Rec. H.265: Weighted prediction parameter */ + struct v4l2_hevc_pred_weight_table pred_weight_table; + -+ __u32 slice_segment_addr; -+ __u32 num_entry_point_offsets; -+ __u32 entry_point_offset_minus1[256]; -+ __u8 first_slice_segment_in_pic_flag; -+ -+ __u8 padding; ++ __u64 flags; +}; + +struct v4l2_ctrl_hevc_scaling_matrix { @@ -565,7 +592,7 @@ index 0000000000..6601455b3d + +#endif diff --git a/libavcodec/v4l2_request_h264.c b/libavcodec/v4l2_request_h264.c -index fb9913922d..b826c9d356 100644 +index 81b3c4b092..ca306b6a3f 100644 --- a/libavcodec/v4l2_request_h264.c +++ b/libavcodec/v4l2_request_h264.c @@ -19,6 +19,7 @@ @@ -577,7 +604,7 @@ index fb9913922d..b826c9d356 100644 typedef struct V4L2RequestControlsH264 { struct v4l2_ctrl_h264_sps sps; diff --git a/libavcodec/v4l2_request_hevc.c b/libavcodec/v4l2_request_hevc.c -index 38969d77fb..b73eb2ab03 100644 +index da1fd666d7..94977c5d0e 100644 --- a/libavcodec/v4l2_request_hevc.c +++ b/libavcodec/v4l2_request_hevc.c @@ -19,6 +19,7 @@ @@ -730,3 +757,6 @@ index 0000000000..53cba826e4 +}; + +#endif +-- +2.24.0 + diff --git a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0008-hwcontext_drm-do-not-require-drm-device.patch b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0008-hwcontext_drm-do-not-require-drm-device.patch index b8a4cc14ff..fa81658595 100644 --- a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0008-hwcontext_drm-do-not-require-drm-device.patch +++ b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0008-hwcontext_drm-do-not-require-drm-device.patch @@ -1,7 +1,7 @@ -From 0c4c87e72463da1a4bf45032e4db3c2c86d6d8d8 Mon Sep 17 00:00:00 2001 +From 6b20e11c96907fb474b1bf33615223bf79eba9c0 Mon Sep 17 00:00:00 2001 From: Jonas Karlman Date: Mon, 29 Apr 2019 22:08:59 +0000 -Subject: [PATCH] hwcontext_drm: do not require drm device +Subject: [PATCH 08/12] hwcontext_drm: do not require drm device Signed-off-by: Jonas Karlman --- @@ -24,3 +24,6 @@ index 32cbde82eb..aa4794c5e6 100644 hwctx->fd = open(device, O_RDWR); if (hwctx->fd < 0) return AVERROR(errno); +-- +2.24.0 + diff --git a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0009-avcodec-h264-parse-idr_pic_id.patch b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0009-avcodec-h264-parse-idr_pic_id.patch index 085c87328a..e9c3524970 100644 --- a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0009-avcodec-h264-parse-idr_pic_id.patch +++ b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0009-avcodec-h264-parse-idr_pic_id.patch @@ -1,7 +1,7 @@ -From 3d50f433609688b6d4ffb2bcec41507f7f507dc2 Mon Sep 17 00:00:00 2001 +From 4c1ce1fde5ca6d3e80bb0d5ab44f2e05f8372db0 Mon Sep 17 00:00:00 2001 From: Ezequiel Garcia Date: Wed, 20 Feb 2019 11:18:00 -0300 -Subject: [PATCH] avcodec/h264: parse idr_pic_id +Subject: [PATCH 09/12] avcodec/h264: parse idr_pic_id Signed-off-by: Ezequiel Garcia --- @@ -37,10 +37,10 @@ index b0b42b7672..38efab5c60 100644 int chroma_qp[2]; // QPc int qp_thresh; ///< QP threshold to skip loopfilter diff --git a/libavcodec/v4l2_request_h264.c b/libavcodec/v4l2_request_h264.c -index b826c9d356..a49773b228 100644 +index ca306b6a3f..f21c8b3508 100644 --- a/libavcodec/v4l2_request_h264.c +++ b/libavcodec/v4l2_request_h264.c -@@ -284,7 +284,7 @@ static int v4l2_request_h264_decode_slice(AVCodecContext *avctx, const uint8_t * +@@ -301,7 +301,7 @@ static int v4l2_request_h264_decode_slice(AVCodecContext *avctx, const uint8_t * .pic_parameter_set_id = sl->pps_id, .colour_plane_id = 0, /* what is this? */ .frame_num = h->poc.frame_num, @@ -49,3 +49,6 @@ index b826c9d356..a49773b228 100644 .pic_order_cnt_lsb = sl->poc_lsb, .delta_pic_order_cnt_bottom = sl->delta_poc_bottom, .delta_pic_order_cnt0 = sl->delta_poc[0], +-- +2.24.0 + diff --git a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0010-avcodec-h264-parse-ref_pic_marking_size_in_bits-and-.patch b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0010-avcodec-h264-parse-ref_pic_marking_size_in_bits-and-.patch index 55103f97cb..43f72ea2d4 100644 --- a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0010-avcodec-h264-parse-ref_pic_marking_size_in_bits-and-.patch +++ b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0010-avcodec-h264-parse-ref_pic_marking_size_in_bits-and-.patch @@ -1,7 +1,7 @@ -From 2f915e957c6bc5887cc24a8762fdadea17359f57 Mon Sep 17 00:00:00 2001 +From 0a7b4a2cffae5d37b753b3e4cc8cadd7204ef5f5 Mon Sep 17 00:00:00 2001 From: Boris Brezillon Date: Wed, 22 May 2019 14:44:22 +0200 -Subject: [PATCH] avcodec/h264: parse ref_pic_marking_size_in_bits and +Subject: [PATCH 10/12] avcodec/h264: parse ref_pic_marking_size_in_bits and pic_order_cnt_bit_size Signed-off-by: Boris Brezillon @@ -71,10 +71,10 @@ index 38efab5c60..8e894f565b 100644 int max_pic_num; } H264SliceContext; diff --git a/libavcodec/v4l2_request_h264.c b/libavcodec/v4l2_request_h264.c -index a49773b228..229df6969d 100644 +index f21c8b3508..1a7fb873a0 100644 --- a/libavcodec/v4l2_request_h264.c +++ b/libavcodec/v4l2_request_h264.c -@@ -292,9 +292,9 @@ static int v4l2_request_h264_decode_slice(AVCodecContext *avctx, const uint8_t * +@@ -309,9 +309,9 @@ static int v4l2_request_h264_decode_slice(AVCodecContext *avctx, const uint8_t * .redundant_pic_cnt = sl->redundant_pic_count, /* Size in bits of dec_ref_pic_marking() syntax element. */ @@ -86,3 +86,6 @@ index a49773b228..229df6969d 100644 .cabac_init_idc = sl->cabac_init_idc, .slice_qp_delta = sl->qscale - pps->init_qp, +-- +2.24.0 + diff --git a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0011-HACK-add-dpb-flags-for-reference-usage-and-field-pic.patch b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0011-HACK-add-dpb-flags-for-reference-usage-and-field-pic.patch index 5c13116c3c..7c1ae0bc8a 100644 --- a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0011-HACK-add-dpb-flags-for-reference-usage-and-field-pic.patch +++ b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0011-HACK-add-dpb-flags-for-reference-usage-and-field-pic.patch @@ -1,7 +1,8 @@ -From 45df99d31062e068073cf899dce559e334c9127f Mon Sep 17 00:00:00 2001 +From 1a2197eea4da8f118726963e0c74647532029306 Mon Sep 17 00:00:00 2001 From: Jonas Karlman Date: Fri, 24 May 2019 22:58:24 +0000 -Subject: [PATCH] HACK: add dpb flags for reference usage and field picture +Subject: [PATCH 11/12] HACK: add dpb flags for reference usage and field + picture This or something similar needs to be upstreamed to kernel h264 ctrls @@ -27,10 +28,10 @@ index e877bf1d53..76020ebd1e 100644 struct v4l2_h264_dpb_entry { __u64 reference_ts; diff --git a/libavcodec/v4l2_request_h264.c b/libavcodec/v4l2_request_h264.c -index 229df6969d..7f345b1955 100644 +index 1a7fb873a0..13fac3f6f9 100644 --- a/libavcodec/v4l2_request_h264.c +++ b/libavcodec/v4l2_request_h264.c -@@ -65,10 +65,13 @@ static void fill_dpb_entry(struct v4l2_h264_dpb_entry *entry, const H264Picture +@@ -66,10 +66,13 @@ static void fill_dpb_entry(struct v4l2_h264_dpb_entry *entry, const H264Picture entry->frame_num = pic->frame_num; entry->pic_num = pic->pic_id; entry->flags = V4L2_H264_DPB_ENTRY_FLAG_VALID; @@ -44,7 +45,7 @@ index 229df6969d..7f345b1955 100644 if (pic->field_poc[0] != INT_MAX) entry->top_field_order_cnt = pic->field_poc[0]; if (pic->field_poc[1] != INT_MAX) -@@ -108,7 +111,8 @@ static uint8_t get_dpb_index(struct v4l2_ctrl_h264_decode_params *decode, const +@@ -109,7 +112,8 @@ static uint8_t get_dpb_index(struct v4l2_ctrl_h264_decode_params *decode, const struct v4l2_h264_dpb_entry *entry = &decode->dpb[i]; if ((entry->flags & V4L2_H264_DPB_ENTRY_FLAG_VALID) && entry->reference_ts == timestamp) @@ -54,3 +55,6 @@ index 229df6969d..7f345b1955 100644 } return 0; +-- +2.24.0 + diff --git a/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0012-WIP-v4l2-request-rolling-timestamps.patch b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0012-WIP-v4l2-request-rolling-timestamps.patch new file mode 100644 index 0000000000..de901b0665 --- /dev/null +++ b/packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0012-WIP-v4l2-request-rolling-timestamps.patch @@ -0,0 +1,72 @@ +From a205c82e430dafd90485b804ce40c1b42cbf9edf Mon Sep 17 00:00:00 2001 +From: Jernej Skrabec +Date: Sat, 9 Nov 2019 10:02:43 +0000 +Subject: [PATCH 12/12] WIP: v4l2-request: rolling timestamps + +--- + libavcodec/v4l2_request.c | 10 +++++++--- + libavcodec/v4l2_request.h | 1 + + 2 files changed, 8 insertions(+), 3 deletions(-) + +diff --git a/libavcodec/v4l2_request.c b/libavcodec/v4l2_request.c +index 1dabf77689..611c22f8b6 100644 +--- a/libavcodec/v4l2_request.c ++++ b/libavcodec/v4l2_request.c +@@ -105,12 +105,14 @@ static int v4l2_request_queue_buffer(V4L2RequestContext *ctx, int request_fd, V4 + .type = buf->buffer.type, + .memory = buf->buffer.memory, + .index = buf->index, +- .timestamp.tv_usec = buf->index + 1, ++ .timestamp.tv_usec = ctx->timestamp, + .bytesused = buf->used, + .request_fd = request_fd, + .flags = ((request_fd >= 0) ? V4L2_BUF_FLAG_REQUEST_FD : 0) | flags, + }; + ++ buf->buffer.timestamp = buffer.timestamp; ++ + if (V4L2_TYPE_IS_MULTIPLANAR(buf->buffer.type)) { + planes[0].bytesused = buf->used; + buffer.bytesused = 0; +@@ -200,6 +202,9 @@ static int v4l2_request_queue_decode(AVCodecContext *avctx, AVFrame *frame, stru + + av_log(avctx, AV_LOG_DEBUG, "%s: avctx=%p used=%u controls=%d index=%d fd=%d request_fd=%d first_slice=%d last_slice=%d\n", __func__, avctx, req->output.used, count, req->capture.index, req->capture.fd, req->request_fd, first_slice, last_slice); + ++ if (first_slice) ++ ctx->timestamp++; ++ + ret = v4l2_request_set_controls(ctx, req->request_fd, control, count); + if (ret < 0) { + av_log(avctx, AV_LOG_ERROR, "%s: set controls failed for request %d, %s (%d)\n", __func__, req->request_fd, strerror(errno), errno); +@@ -651,6 +656,7 @@ int ff_v4l2_request_init(AVCodecContext *avctx, uint32_t pixelformat, uint32_t b + + ctx->media_fd = -1; + ctx->video_fd = -1; ++ ctx->timestamp = 0; + + udev = udev_new(); + if (!udev) { +@@ -784,8 +790,6 @@ static int v4l2_request_buffer_alloc(AVCodecContext *avctx, V4L2RequestBuffer *b + return ret; + } + +- buf->buffer.timestamp.tv_usec = buf->index + 1; +- + if (V4L2_TYPE_IS_OUTPUT(type)) { + void *addr = mmap(NULL, buf->size, PROT_READ | PROT_WRITE, MAP_SHARED, ctx->video_fd, V4L2_TYPE_IS_MULTIPLANAR(type) ? buf->buffer.m.planes[0].m.mem_offset : buf->buffer.m.offset); + if (addr == MAP_FAILED) { +diff --git a/libavcodec/v4l2_request.h b/libavcodec/v4l2_request.h +index d4146bd4ee..72698f6f3c 100644 +--- a/libavcodec/v4l2_request.h ++++ b/libavcodec/v4l2_request.h +@@ -28,6 +28,7 @@ typedef struct V4L2RequestContext { + int media_fd; + enum v4l2_buf_type output_type; + struct v4l2_format format; ++ int timestamp; + } V4L2RequestContext; + + typedef struct V4L2RequestBuffer { +-- +2.24.0 +