jeans/LibreELEC.tv
jeans/LibreELEC.tv
1
0
Fork 0
mirror of https://github.com/LibreELEC/LibreELEC.tv.git synced 2025-08-02 07:27:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

ffmpeg: Update request api patches

Browse Source
This commit is contained in:
Jernej Skrabec 2019-10-27 12:35:49 +01:00
parent a182767d1e
commit eebc912afa
12 changed files with 493 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0001-avutil-add-av_buffer_pool_flush.patch
View File

@ -1,7 +1,7 @@
From e6cec3f54693e7e2c10b6b7bc8f72daa6e9a77dc Mon Sep 17 00:00:00 2001 From e6cec3f54693e7e2c10b6b7bc8f72daa6e9a77dc Mon Sep 17 00:00:00 2001
From: Jonas Karlman <jonas@kwiboo.se> From: Jonas Karlman <jonas@kwiboo.se>
Date: Mon, 3 Dec 2018 23:48:04 +0100 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 <jonas@kwiboo.se> Signed-off-by: Jonas Karlman <jonas@kwiboo.se>
--- ---
@ -49,3 +49,6 @@ index 73b6bd0b14..0678fa4bea 100644
/** /**
* Mark the pool as being available for freeing. It will actually be freed only * 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 * once all the allocated buffers associated with the pool are released. Thus it
--
2.24.0

60
packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0002-Add-common-V4L2-request-API-code.patch
View File

@ -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 <jonas@kwiboo.se> From: Jonas Karlman <jonas@kwiboo.se>
Date: Sat, 15 Dec 2018 22:32:16 +0100 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 <jonas@kwiboo.se> Signed-off-by: Jonas Karlman <jonas@kwiboo.se>
--- ---
configure | 12 + configure | 12 +
libavcodec/Makefile | 1 + libavcodec/Makefile | 1 +
libavcodec/hwaccel.h | 2 + libavcodec/hwaccel.h | 2 +
libavcodec/v4l2_request.c | 919 ++++++++++++++++++++++++++++++++++++++ libavcodec/v4l2_request.c | 943 ++++++++++++++++++++++++++++++++++++++
libavcodec/v4l2_request.h | 69 +++ libavcodec/v4l2_request.h | 72 +++
5 files changed, 1003 insertions(+) 5 files changed, 1030 insertions(+)
create mode 100644 libavcodec/v4l2_request.c create mode 100644 libavcodec/v4l2_request.c
create mode 100644 libavcodec/v4l2_request.h create mode 100644 libavcodec/v4l2_request.h
@ -112,10 +112,10 @@ index 3aaa92571c..2eefc91e7e 100644
#endif /* AVCODEC_HWACCEL_H */ #endif /* AVCODEC_HWACCEL_H */
diff --git a/libavcodec/v4l2_request.c b/libavcodec/v4l2_request.c diff --git a/libavcodec/v4l2_request.c b/libavcodec/v4l2_request.c
new file mode 100644 new file mode 100644
index 0000000000..bf9d049eff index 0000000000..1dabf77689
--- /dev/null --- /dev/null
+++ b/libavcodec/v4l2_request.c +++ b/libavcodec/v4l2_request.c
@@ -0,0 +1,919 @@ @@ -0,0 +1,943 @@
+/* +/*
+ * This file is part of FFmpeg. + * This file is part of FFmpeg.
+ * + *
@ -216,7 +216,7 @@ index 0000000000..bf9d049eff
+ return control.default_value; + 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_plane planes[1] = {};
+ struct v4l2_buffer buffer = { + struct v4l2_buffer buffer = {
@ -226,7 +226,7 @@ index 0000000000..bf9d049eff
+ .timestamp.tv_usec = buf->index + 1, + .timestamp.tv_usec = buf->index + 1,
+ .bytesused = buf->used, + .bytesused = buf->used,
+ .request_fd = request_fd, + .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)) { + if (V4L2_TYPE_IS_MULTIPLANAR(buf->buffer.type)) {
@ -308,7 +308,7 @@ index 0000000000..bf9d049eff
+ return 0; + 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; + V4L2RequestContext *ctx = avctx->internal->hwaccel_priv_data;
+ V4L2RequestDescriptor *req = (V4L2RequestDescriptor*)frame->data[0]; + V4L2RequestDescriptor *req = (V4L2RequestDescriptor*)frame->data[0];
@ -316,7 +316,7 @@ index 0000000000..bf9d049eff
+ fd_set except_fds; + fd_set except_fds;
+ int ret; + 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); + ret = v4l2_request_set_controls(ctx, req->request_fd, control, count);
+ if (ret < 0) { + if (ret < 0) {
@ -326,17 +326,19 @@ index 0000000000..bf9d049eff
+ +
+ memset(req->output.addr + req->output.used, 0, AV_INPUT_BUFFER_PADDING_SIZE); + 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) { + 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); + 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; + return -1;
+ } + }
+ +
+ ret = v4l2_request_queue_buffer(ctx, -1, &req->capture); + if (first_slice) {
+ ret = v4l2_request_queue_buffer(ctx, -1, &req->capture, 0);
+ if (ret < 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); + 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; + return -1;
+ } + }
+ }
+ +
+ // NOTE: do we need to dequeue when request fails/timeout? + // NOTE: do we need to dequeue when request fails/timeout?
+ +
@ -365,11 +367,13 @@ index 0000000000..bf9d049eff
+ return -1; + return -1;
+ } + }
+ +
+ if (last_slice) {
+ ret = v4l2_request_dequeue_buffer(ctx, &req->capture); + ret = v4l2_request_dequeue_buffer(ctx, &req->capture);
+ if (ret < 0) { + 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); + 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; + return -1;
+ } + }
+ }
+ +
+ // TODO: check errors + // TODO: check errors
+ // buffer.flags & V4L2_BUF_FLAG_ERROR + // buffer.flags & V4L2_BUF_FLAG_ERROR
@ -380,8 +384,11 @@ index 0000000000..bf9d049eff
+ return -1; + return -1;
+ } + }
+ +
+ if (last_slice)
+ return v4l2_request_set_drm_descriptor(req, &ctx->format); + return v4l2_request_set_drm_descriptor(req, &ctx->format);
+ +
+ return 0;
+
+fail: +fail:
+ ret = v4l2_request_dequeue_buffer(ctx, &req->output); + ret = v4l2_request_dequeue_buffer(ctx, &req->output);
+ if (ret < 0) + if (ret < 0)
@ -398,6 +405,22 @@ index 0000000000..bf9d049eff
+ return -1; + 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) +static int v4l2_request_try_format(AVCodecContext *avctx, enum v4l2_buf_type type, uint32_t pixelformat)
+{ +{
+ V4L2RequestContext *ctx = avctx->internal->hwaccel_priv_data; + V4L2RequestContext *ctx = avctx->internal->hwaccel_priv_data;
@ -866,6 +889,7 @@ index 0000000000..bf9d049eff
+ } + }
+ +
+ buf->index = buffers.index; + buf->index = buffers.index;
+ buf->capabilities = buffers.capabilities;
+ buf->used = 0; + buf->used = 0;
+ +
+ buf->buffer.type = type; + buf->buffer.type = type;
@ -1037,10 +1061,10 @@ index 0000000000..bf9d049eff
+} +}
diff --git a/libavcodec/v4l2_request.h b/libavcodec/v4l2_request.h diff --git a/libavcodec/v4l2_request.h b/libavcodec/v4l2_request.h
new file mode 100644 new file mode 100644
index 0000000000..1f45772d8b index 0000000000..d4146bd4ee
--- /dev/null --- /dev/null
+++ b/libavcodec/v4l2_request.h +++ b/libavcodec/v4l2_request.h
@@ -0,0 +1,69 @@ @@ -0,0 +1,72 @@
+/* +/*
+ * This file is part of FFmpeg. + * This file is part of FFmpeg.
+ * + *
@ -1081,6 +1105,7 @@ index 0000000000..1f45772d8b
+ uint32_t height; + uint32_t height;
+ uint32_t size; + uint32_t size;
+ uint32_t used; + uint32_t used;
+ uint32_t capabilities;
+ struct v4l2_buffer buffer; + struct v4l2_buffer buffer;
+} V4L2RequestBuffer; +} 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_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_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); +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); +int ff_v4l2_request_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx);
+ +
+#endif /* AVCODEC_V4L2_REQUEST_H */ +#endif /* AVCODEC_V4L2_REQUEST_H */
--
2.24.0

7
packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0003-Add-V4L2-request-API-mpeg2-hwaccel.patch
View File

@ -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 <jonas@kwiboo.se> From: Jonas Karlman <jonas@kwiboo.se>
Date: Sat, 15 Dec 2018 22:32:16 +0100 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 <jonas@kwiboo.se> Signed-off-by: Jonas Karlman <jonas@kwiboo.se>
--- ---
@ -242,3 +242,6 @@ index 0000000000..782b9c2471
+ .frame_params = ff_v4l2_request_frame_params, + .frame_params = ff_v4l2_request_frame_params,
+ .caps_internal = HWACCEL_CAP_ASYNC_SAFE, + .caps_internal = HWACCEL_CAP_ASYNC_SAFE,
+}; +};
--
2.24.0

44
packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0004-Add-V4L2-request-API-h264-hwaccel.patch
View File

@ -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 <jernej.skrabec@siol.net> From: Jernej Skrabec <jernej.skrabec@siol.net>
Date: Sat, 15 Dec 2018 22:32:16 +0100 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 <jernej.skrabec@siol.net> Signed-off-by: Jernej Skrabec <jernej.skrabec@siol.net>
Signed-off-by: Jonas Karlman <jonas@kwiboo.se> Signed-off-by: Jonas Karlman <jonas@kwiboo.se>
@ -11,8 +11,8 @@ Signed-off-by: Jonas Karlman <jonas@kwiboo.se>
libavcodec/h264_slice.c | 4 + libavcodec/h264_slice.c | 4 +
libavcodec/h264dec.c | 3 + libavcodec/h264dec.c | 3 +
libavcodec/hwaccels.h | 1 + libavcodec/hwaccels.h | 1 +
libavcodec/v4l2_request_h264.c | 420 +++++++++++++++++++++++++++++++++ libavcodec/v4l2_request_h264.c | 443 +++++++++++++++++++++++++++++++++
6 files changed, 432 insertions(+) 6 files changed, 455 insertions(+)
create mode 100644 libavcodec/v4l2_request_h264.c create mode 100644 libavcodec/v4l2_request_h264.c
diff --git a/configure b/configure diff --git a/configure b/configure
@ -98,10 +98,10 @@ index ef54de2a3b..003200edea 100644
extern const AVHWAccel ff_h264_videotoolbox_hwaccel; extern const AVHWAccel ff_h264_videotoolbox_hwaccel;
diff --git a/libavcodec/v4l2_request_h264.c b/libavcodec/v4l2_request_h264.c diff --git a/libavcodec/v4l2_request_h264.c b/libavcodec/v4l2_request_h264.c
new file mode 100644 new file mode 100644
index 0000000000..fb9913922d index 0000000000..81b3c4b092
--- /dev/null --- /dev/null
+++ b/libavcodec/v4l2_request_h264.c +++ b/libavcodec/v4l2_request_h264.c
@@ -0,0 +1,420 @@ @@ -0,0 +1,443 @@
+/* +/*
+ * This file is part of FFmpeg. + * 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_scaling_matrix scaling_matrix;
+ struct v4l2_ctrl_h264_decode_params decode_params; + struct v4l2_ctrl_h264_decode_params decode_params;
+ struct v4l2_ctrl_h264_slice_params slice_params[16]; + struct v4l2_ctrl_h264_slice_params slice_params[16];
+ int first_slice;
+} V4L2RequestControlsH264; +} V4L2RequestControlsH264;
+ +
+typedef struct V4L2RequestContextH264 { +typedef struct V4L2RequestContextH264 {
@ -297,13 +298,22 @@ index 0000000000..fb9913922d
+{ +{
+ const H264Context *h = avctx->priv_data; + const H264Context *h = avctx->priv_data;
+ const PPS *pps = h->ps.pps; + const PPS *pps = h->ps.pps;
+ const SPS *sps = h->ps.sps;
+ V4L2RequestControlsH264 *controls = h->cur_pic_ptr->hwaccel_picture_private; + V4L2RequestControlsH264 *controls = h->cur_pic_ptr->hwaccel_picture_private;
+ +
+ fill_sps(&controls->sps, h); + fill_sps(&controls->sps, h);
+ fill_pps(&controls->pps, 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_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) { + controls->decode_params = (struct v4l2_ctrl_h264_decode_params) {
+ .num_slices = 0, + .num_slices = 0,
@ -317,13 +327,16 @@ index 0000000000..fb9913922d
+ +
+ fill_dpb(&controls->decode_params, h); + 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); + 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; + const H264Context *h = avctx->priv_data;
+ V4L2RequestControlsH264 *controls = h->cur_pic_ptr->hwaccel_picture_private; + V4L2RequestControlsH264 *controls = h->cur_pic_ptr->hwaccel_picture_private;
+ V4L2RequestContextH264 *ctx = avctx->internal->hwaccel_priv_data;
+ +
+ struct v4l2_ext_control control[] = { + 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)); + 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); + 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) { + 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) + if (ret)
+ return ret; + return ret;
+ +
+ ff_v4l2_request_reset_frame(avctx, h->cur_pic_ptr->f); + ff_v4l2_request_reset_frame(avctx, h->cur_pic_ptr->f);
+ slice = controls->decode_params.num_slices = 0; + slice = controls->decode_params.num_slices = 0;
+ controls->first_slice = 0;
+ } + }
+ +
+ controls->slice_params[slice] = (struct v4l2_ctrl_h264_slice_params) { + controls->slice_params[slice] = (struct v4l2_ctrl_h264_slice_params) {
@ -448,6 +465,12 @@ index 0000000000..fb9913922d
+ return 0; + 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) +static int v4l2_request_h264_set_controls(AVCodecContext *avctx)
+{ +{
+ V4L2RequestContextH264 *ctx = avctx->internal->hwaccel_priv_data; + V4L2RequestContextH264 *ctx = avctx->internal->hwaccel_priv_data;
@ -522,3 +545,6 @@ index 0000000000..fb9913922d
+ .frame_params = ff_v4l2_request_frame_params, + .frame_params = ff_v4l2_request_frame_params,
+ .caps_internal = HWACCEL_CAP_ASYNC_SAFE, + .caps_internal = HWACCEL_CAP_ASYNC_SAFE,
+}; +};
--
2.24.0

259
packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0005-Add-V4L2-request-API-hevc-hwaccel.patch
View File

@ -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 <jernej.skrabec@siol.net> From: Jernej Skrabec <jernej.skrabec@siol.net>
Date: Sat, 15 Dec 2018 22:32:16 +0100 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 <jernej.skrabec@siol.net> Signed-off-by: Jernej Skrabec <jernej.skrabec@siol.net>
Signed-off-by: Jonas Karlman <jonas@kwiboo.se> Signed-off-by: Jonas Karlman <jonas@kwiboo.se>
@ -10,8 +10,8 @@ Signed-off-by: Jonas Karlman <jonas@kwiboo.se>
libavcodec/Makefile | 1 + libavcodec/Makefile | 1 +
libavcodec/hevcdec.c | 10 + libavcodec/hevcdec.c | 10 +
libavcodec/hwaccels.h | 1 + libavcodec/hwaccels.h | 1 +
libavcodec/v4l2_request_hevc.c | 391 +++++++++++++++++++++++++++++++++ libavcodec/v4l2_request_hevc.c | 527 +++++++++++++++++++++++++++++++++
5 files changed, 406 insertions(+) 5 files changed, 542 insertions(+)
create mode 100644 libavcodec/v4l2_request_hevc.c create mode 100644 libavcodec/v4l2_request_hevc.c
diff --git a/configure b/configure diff --git a/configure b/configure
@ -103,10 +103,10 @@ index 003200edea..d183675abe 100644
extern const AVHWAccel ff_hevc_videotoolbox_hwaccel; extern const AVHWAccel ff_hevc_videotoolbox_hwaccel;
diff --git a/libavcodec/v4l2_request_hevc.c b/libavcodec/v4l2_request_hevc.c diff --git a/libavcodec/v4l2_request_hevc.c b/libavcodec/v4l2_request_hevc.c
new file mode 100644 new file mode 100644
index 0000000000..38969d77fb index 0000000000..da1fd666d7
--- /dev/null --- /dev/null
+++ b/libavcodec/v4l2_request_hevc.c +++ b/libavcodec/v4l2_request_hevc.c
@@ -0,0 +1,391 @@ @@ -0,0 +1,527 @@
+/* +/*
+ * This file is part of FFmpeg. + * This file is part of FFmpeg.
+ * + *
@ -133,9 +133,17 @@ index 0000000000..38969d77fb
+ struct v4l2_ctrl_hevc_sps sps; + struct v4l2_ctrl_hevc_sps sps;
+ struct v4l2_ctrl_hevc_pps pps; + struct v4l2_ctrl_hevc_pps pps;
+ struct v4l2_ctrl_hevc_scaling_matrix scaling_matrix; + 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; +} 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) +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; + int32_t luma_weight_denom, chroma_weight_denom;
@ -233,6 +241,9 @@ index 0000000000..38969d77fb
+ .bit_size = 0, + .bit_size = 0,
+ .data_bit_offset = get_bits_count(&h->HEVClc->gb), + .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 */ + /* ISO/IEC 23008-2, ITU-T Rec. H.265: NAL unit header */
+ .nal_unit_type = h->nal_unit_type, + .nal_unit_type = h->nal_unit_type,
+ .nuh_temporal_id_plus1 = h->temporal_id + 1, + .nuh_temporal_id_plus1 = h->temporal_id + 1,
@ -241,27 +252,18 @@ index 0000000000..38969d77fb
+ .slice_type = sh->slice_type, + .slice_type = sh->slice_type,
+ .colour_plane_id = sh->colour_plane_id, + .colour_plane_id = sh->colour_plane_id,
+ .slice_pic_order_cnt = pic->poc, + .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_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, + .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, + .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, + .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_qp_delta = sh->slice_qp_delta,
+ .slice_cb_qp_offset = sh->slice_cb_qp_offset, + .slice_cb_qp_offset = sh->slice_cb_qp_offset,
+ .slice_cr_qp_offset = sh->slice_cr_qp_offset, + .slice_cr_qp_offset = sh->slice_cr_qp_offset,
+ .slice_act_y_qp_offset = 0, + .slice_act_y_qp_offset = 0,
+ .slice_act_cb_qp_offset = 0, + .slice_act_cb_qp_offset = 0,
+ .slice_act_cr_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_beta_offset_div2 = sh->beta_offset / 2,
+ .slice_tc_offset_div2 = sh->tc_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 */ + /* ISO/IEC 23008-2, ITU-T Rec. H.265: Picture timing SEI message */
+ .pic_struct = h->sei.picture_timing.picture_struct, + .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_before = h->rps[ST_CURR_BEF].nb_refs,
+ .num_rps_poc_st_curr_after = h->rps[ST_CURR_AFT].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, + .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++) { + for (i = 0; i < FF_ARRAY_ELEMS(h->DPB); i++) {
+ const HEVCFrame *frame = &h->DPB[i]; + const HEVCFrame *frame = &h->DPB[i];
+ if (frame != pic && (frame->flags & (HEVC_FRAME_FLAG_LONG_REF | HEVC_FRAME_FLAG_SHORT_REF))) { + 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 */ + /* ISO/IEC 23008-2, ITU-T Rec. H.265: Sequence parameter set */
+ controls->sps = (struct v4l2_ctrl_hevc_sps) { + controls->sps = (struct v4l2_ctrl_hevc_sps) {
+ .chroma_format_idc = sps->chroma_format_idc, + .chroma_format_idc = sps->chroma_format_idc,
+ .separate_colour_plane_flag = sps->separate_colour_plane_flag,
+ .pic_width_in_luma_samples = sps->width, + .pic_width_in_luma_samples = sps->width,
+ .pic_height_in_luma_samples = sps->height, + .pic_height_in_luma_samples = sps->height,
+ .bit_depth_luma_minus8 = sps->bit_depth - 8, + .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, + .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_inter = sps->max_transform_hierarchy_depth_inter,
+ .max_transform_hierarchy_depth_intra = sps->max_transform_hierarchy_depth_intra, + .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_luma_minus1 = sps->pcm.bit_depth - 1,
+ .pcm_sample_bit_depth_chroma_minus1 = sps->pcm.bit_depth_chroma - 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_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, + .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, + .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, + .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) { + if (sl) {
+ for (int i = 0; i < 6; i++) { + for (int i = 0; i < 6; i++) {
+ for (int j = 0; j < 16; j++) + 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 */ + /* ISO/IEC 23008-2, ITU-T Rec. H.265: Picture parameter set */
+ controls->pps = (struct v4l2_ctrl_hevc_pps) { + 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, + .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, + .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, + .diff_cu_qp_delta_depth = pps->diff_cu_qp_delta_depth,
+ .pps_cb_qp_offset = pps->cb_qp_offset, + .pps_cb_qp_offset = pps->cb_qp_offset,
+ .pps_cr_qp_offset = pps->cr_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_beta_offset_div2 = pps->beta_offset / 2,
+ .pps_tc_offset_div2 = pps->tc_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, + .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) { + if (pps->tiles_enabled_flag) {
+ controls->pps.num_tile_columns_minus1 = pps->num_tile_columns - 1; + controls->pps.num_tile_columns_minus1 = pps->num_tile_columns - 1;
+ controls->pps.num_tile_rows_minus1 = pps->num_tile_rows - 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++) + for (int i = 0; i < pps->num_tile_columns; i++)
+ controls->pps.column_width_minus1[i] = pps->column_width[i] - 1; + 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->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); + 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; + const HEVCContext *h = avctx->priv_data;
+ V4L2RequestControlsHEVC *controls = h->ref->hwaccel_picture_private; + 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[] = { + struct v4l2_ext_control control[] = {
+ { + {
@ -452,35 +534,89 @@ index 0000000000..38969d77fb
+ { + {
+ .id = V4L2_CID_MPEG_VIDEO_HEVC_SLICE_PARAMS, + .id = V4L2_CID_MPEG_VIDEO_HEVC_SLICE_PARAMS,
+ .ptr = &controls->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)); + 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) +static int v4l2_request_hevc_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
+{ +{
+ const HEVCContext *h = avctx->priv_data; + const HEVCContext *h = avctx->priv_data;
+ V4L2RequestControlsHEVC *controls = h->ref->hwaccel_picture_private; + V4L2RequestControlsHEVC *controls = h->ref->hwaccel_picture_private;
+ V4L2RequestDescriptor *req = (V4L2RequestDescriptor*)h->ref->frame->data[0]; + V4L2RequestDescriptor *req = (V4L2RequestDescriptor*)h->ref->frame->data[0];
+ V4L2RequestContextHEVC *ctx = avctx->internal->hwaccel_priv_data;
+ int ret, slice = FFMIN(controls->num_slices, 15);
+
+ 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;
+ +
+ // HACK: trigger decode per slice
+ if (req->output.used) {
+ v4l2_request_hevc_end_frame(avctx);
+ ff_v4l2_request_reset_frame(avctx, h->ref->frame); + 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) +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 = { +const AVHWAccel ff_hevc_v4l2request_hwaccel = {
@ -494,7 +630,10 @@ index 0000000000..38969d77fb
+ .frame_priv_data_size = sizeof(V4L2RequestControlsHEVC), + .frame_priv_data_size = sizeof(V4L2RequestControlsHEVC),
+ .init = v4l2_request_hevc_init, + .init = v4l2_request_hevc_init,
+ .uninit = ff_v4l2_request_uninit, + .uninit = ff_v4l2_request_uninit,
+ .priv_data_size = sizeof(V4L2RequestContext), + .priv_data_size = sizeof(V4L2RequestContextHEVC),
+ .frame_params = ff_v4l2_request_frame_params, + .frame_params = ff_v4l2_request_frame_params,
+ .caps_internal = HWACCEL_CAP_ASYNC_SAFE, + .caps_internal = HWACCEL_CAP_ASYNC_SAFE,
+}; +};
--
2.24.0

7
packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0006-Add-V4L2-request-API-vp8-hwaccel.patch
View File

@ -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 <boris.brezillon@collabora.com> From: Boris Brezillon <boris.brezillon@collabora.com>
Date: Wed, 22 May 2019 14:46:58 +0200 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. Need to fix the STREAMOFF/STREAMON issue in a proper way.
@ -280,3 +280,6 @@ index 62b9f8bc2d..55966b9d56 100644
#endif #endif
NULL NULL
}, },
--
2.24.0

152
packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0007-Add-and-use-private-linux-headers-for-V4L2-request-A.patch
View File

@ -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 <jernej.skrabec@siol.net> From: Jernej Skrabec <jernej.skrabec@siol.net>
Date: Thu, 14 Feb 2019 23:20:05 +0100 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 <jernej.skrabec@siol.net> Signed-off-by: Jernej Skrabec <jernej.skrabec@siol.net>
--- ---
configure | 6 +- configure | 6 +-
libavcodec/h264-ctrls.h | 210 ++++++++++++++++++++++++++++++++ libavcodec/h264-ctrls.h | 210 +++++++++++++++++++++++++++++
libavcodec/hevc-ctrls.h | 203 ++++++++++++++++++++++++++++++ libavcodec/hevc-ctrls.h | 229 ++++++++++++++++++++++++++++++++
libavcodec/mpeg2-ctrls.h | 82 +++++++++++++ libavcodec/mpeg2-ctrls.h | 82 ++++++++++++
libavcodec/v4l2_request_h264.c | 1 + libavcodec/v4l2_request_h264.c | 1 +
libavcodec/v4l2_request_hevc.c | 1 + libavcodec/v4l2_request_hevc.c | 1 +
libavcodec/v4l2_request_mpeg2.c | 1 + libavcodec/v4l2_request_mpeg2.c | 1 +
libavcodec/v4l2_request_vp8.c | 1 + libavcodec/v4l2_request_vp8.c | 1 +
libavcodec/vp8-ctrls.h | 112 +++++++++++++++++ libavcodec/vp8-ctrls.h | 112 ++++++++++++++++
9 files changed, 614 insertions(+), 3 deletions(-) 9 files changed, 640 insertions(+), 3 deletions(-)
create mode 100644 libavcodec/h264-ctrls.h create mode 100644 libavcodec/h264-ctrls.h
create mode 100644 libavcodec/hevc-ctrls.h create mode 100644 libavcodec/hevc-ctrls.h
create mode 100644 libavcodec/mpeg2-ctrls.h create mode 100644 libavcodec/mpeg2-ctrls.h
@ -269,10 +270,10 @@ index 0000000000..e877bf1d53
+#endif +#endif
diff --git a/libavcodec/hevc-ctrls.h b/libavcodec/hevc-ctrls.h diff --git a/libavcodec/hevc-ctrls.h b/libavcodec/hevc-ctrls.h
new file mode 100644 new file mode 100644
index 0000000000..eee4479c7a index 0000000000..d1b094c8aa
--- /dev/null --- /dev/null
+++ b/libavcodec/hevc-ctrls.h +++ b/libavcodec/hevc-ctrls.h
@@ -0,0 +1,203 @@ @@ -0,0 +1,229 @@
+/* SPDX-License-Identifier: GPL-2.0 */ +/* SPDX-License-Identifier: GPL-2.0 */
+/* +/*
+ * These are the HEVC state controls for use with stateless HEVC + * 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_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_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_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 */ +/* enum v4l2_ctrl_type type values */
+#define V4L2_CTRL_TYPE_HEVC_SPS 0x0120 +#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_SLICE_PARAMS 0x0122
+#define V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX 0x0123 +#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_B 0
+#define V4L2_HEVC_SLICE_TYPE_P 1 +#define V4L2_HEVC_SLICE_TYPE_P 1
+#define V4L2_HEVC_SLICE_TYPE_I 2 +#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. */ +/* The controls are not stable at the moment and will likely be reworked. */
+struct v4l2_ctrl_hevc_sps { +struct v4l2_ctrl_hevc_sps {
+ /* ISO/IEC 23008-2, ITU-T Rec. H.265: Sequence parameter set */ + /* 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_width_in_luma_samples;
+ __u16 pic_height_in_luma_samples; + __u16 pic_height_in_luma_samples;
+ __u8 bit_depth_luma_minus8; + __u8 bit_depth_luma_minus8;
@ -325,56 +346,56 @@ index 0000000000..eee4479c7a
+ __u8 log2_diff_max_min_luma_transform_block_size; + __u8 log2_diff_max_min_luma_transform_block_size;
+ __u8 max_transform_hierarchy_depth_inter; + __u8 max_transform_hierarchy_depth_inter;
+ __u8 max_transform_hierarchy_depth_intra; + __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_luma_minus1;
+ __u8 pcm_sample_bit_depth_chroma_minus1; + __u8 pcm_sample_bit_depth_chroma_minus1;
+ __u8 log2_min_pcm_luma_coding_block_size_minus3; + __u8 log2_min_pcm_luma_coding_block_size_minus3;
+ __u8 log2_diff_max_min_pcm_luma_coding_block_size; + __u8 log2_diff_max_min_pcm_luma_coding_block_size;
+ __u8 pcm_loop_filter_disabled_flag;
+ __u8 num_short_term_ref_pic_sets; + __u8 num_short_term_ref_pic_sets;
+ __u8 long_term_ref_pics_present_flag;
+ __u8 num_long_term_ref_pics_sps; + __u8 num_long_term_ref_pics_sps;
+ __u8 sps_temporal_mvp_enabled_flag; + __u8 chroma_format_idc;
+ __u8 strong_intra_smoothing_enabled_flag; +
+ __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 { +struct v4l2_ctrl_hevc_pps {
+ /* ISO/IEC 23008-2, ITU-T Rec. H.265: Picture parameter set */ + /* 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 num_extra_slice_header_bits;
+ __u8 sign_data_hiding_enabled_flag;
+ __u8 cabac_init_present_flag;
+ __s8 init_qp_minus26; + __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; + __u8 diff_cu_qp_delta_depth;
+ __s8 pps_cb_qp_offset; + __s8 pps_cb_qp_offset;
+ __s8 pps_cr_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_columns_minus1;
+ __u8 num_tile_rows_minus1; + __u8 num_tile_rows_minus1;
+ __u8 column_width_minus1[20]; + __u8 column_width_minus1[20];
+ __u8 row_height_minus1[22]; + __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_beta_offset_div2;
+ __s8 pps_tc_offset_div2; + __s8 pps_tc_offset_div2;
+ __u8 lists_modification_present_flag;
+ __u8 log2_parallel_merge_level_minus2; + __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 +#define V4L2_HEVC_DPB_ENTRY_RPS_ST_CURR_BEFORE 0x01
@ -392,9 +413,6 @@ index 0000000000..eee4479c7a
+}; +};
+ +
+struct v4l2_hevc_pred_weight_table { +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 delta_luma_weight_l0[V4L2_HEVC_DPB_ENTRIES_NUM_MAX];
+ __s8 luma_offset_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]; + __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 delta_chroma_weight_l1[V4L2_HEVC_DPB_ENTRIES_NUM_MAX][2];
+ __s8 chroma_offset_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 { +struct v4l2_ctrl_hevc_slice_params {
+ __u32 bit_size; + __u32 bit_size;
+ __u32 data_bit_offset; + __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 */ + /* ISO/IEC 23008-2, ITU-T Rec. H.265: NAL unit header */
+ __u8 nal_unit_type; + __u8 nal_unit_type;
+ __u8 nuh_temporal_id_plus1; + __u8 nuh_temporal_id_plus1;
@ -420,33 +455,23 @@ index 0000000000..eee4479c7a
+ __u8 slice_type; + __u8 slice_type;
+ __u8 colour_plane_id; + __u8 colour_plane_id;
+ __u16 slice_pic_order_cnt; + __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_l0_active_minus1;
+ __u8 num_ref_idx_l1_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 collocated_ref_idx;
+ __u8 five_minus_max_num_merge_cand; + __u8 five_minus_max_num_merge_cand;
+ __u8 use_integer_mv_flag;
+ __s8 slice_qp_delta; + __s8 slice_qp_delta;
+ __s8 slice_cb_qp_offset; + __s8 slice_cb_qp_offset;
+ __s8 slice_cr_qp_offset; + __s8 slice_cr_qp_offset;
+ __s8 slice_act_y_qp_offset; + __s8 slice_act_y_qp_offset;
+ __s8 slice_act_cb_qp_offset; + __s8 slice_act_cb_qp_offset;
+ __s8 slice_act_cr_qp_offset; + __s8 slice_act_cr_qp_offset;
+ __u8 slice_deblocking_filter_disabled_flag;
+ __s8 slice_beta_offset_div2; + __s8 slice_beta_offset_div2;
+ __s8 slice_tc_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 */ + /* ISO/IEC 23008-2, ITU-T Rec. H.265: Picture timing SEI message */
+ __u8 pic_struct; + __u8 pic_struct;
+ +
+ /* ISO/IEC 23008-2, ITU-T Rec. H.265: General slice segment header */ + /* 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 num_active_dpb_entries;
+ __u8 ref_idx_l0[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 ref_idx_l0[V4L2_HEVC_DPB_ENTRIES_NUM_MAX];
+ __u8 ref_idx_l1[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_st_curr_after;
+ __u8 num_rps_poc_lt_curr; + __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 */ + /* ISO/IEC 23008-2, ITU-T Rec. H.265: Weighted prediction parameter */
+ struct v4l2_hevc_pred_weight_table pred_weight_table; + struct v4l2_hevc_pred_weight_table pred_weight_table;
+ +
+ __u32 slice_segment_addr; + __u64 flags;
+ __u32 num_entry_point_offsets;
+ __u32 entry_point_offset_minus1[256];
+ __u8 first_slice_segment_in_pic_flag;
+
+ __u8 padding;
+}; +};
+ +
+struct v4l2_ctrl_hevc_scaling_matrix { +struct v4l2_ctrl_hevc_scaling_matrix {
@ -565,7 +592,7 @@ index 0000000000..6601455b3d
+ +
+#endif +#endif
diff --git a/libavcodec/v4l2_request_h264.c b/libavcodec/v4l2_request_h264.c 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 --- a/libavcodec/v4l2_request_h264.c
+++ b/libavcodec/v4l2_request_h264.c +++ b/libavcodec/v4l2_request_h264.c
@@ -19,6 +19,7 @@ @@ -19,6 +19,7 @@
@ -577,7 +604,7 @@ index fb9913922d..b826c9d356 100644
typedef struct V4L2RequestControlsH264 { typedef struct V4L2RequestControlsH264 {
struct v4l2_ctrl_h264_sps sps; struct v4l2_ctrl_h264_sps sps;
diff --git a/libavcodec/v4l2_request_hevc.c b/libavcodec/v4l2_request_hevc.c 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 --- a/libavcodec/v4l2_request_hevc.c
+++ b/libavcodec/v4l2_request_hevc.c +++ b/libavcodec/v4l2_request_hevc.c
@@ -19,6 +19,7 @@ @@ -19,6 +19,7 @@
@ -730,3 +757,6 @@ index 0000000000..53cba826e4
+}; +};
+ +
+#endif +#endif
--
2.24.0

7
packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0008-hwcontext_drm-do-not-require-drm-device.patch
View File

@ -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 <jonas@kwiboo.se> From: Jonas Karlman <jonas@kwiboo.se>
Date: Mon, 29 Apr 2019 22:08:59 +0000 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 <jonas@kwiboo.se> Signed-off-by: Jonas Karlman <jonas@kwiboo.se>
--- ---
@ -24,3 +24,6 @@ index 32cbde82eb..aa4794c5e6 100644
hwctx->fd = open(device, O_RDWR); hwctx->fd = open(device, O_RDWR);
if (hwctx->fd < 0) if (hwctx->fd < 0)
return AVERROR(errno); return AVERROR(errno);
--
2.24.0

11
packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0009-avcodec-h264-parse-idr_pic_id.patch
View File

@ -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 <ezequiel@collabora.com> From: Ezequiel Garcia <ezequiel@collabora.com>
Date: Wed, 20 Feb 2019 11:18:00 -0300 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 <ezequiel@collabora.com> Signed-off-by: Ezequiel Garcia <ezequiel@collabora.com>
--- ---
@ -37,10 +37,10 @@ index b0b42b7672..38efab5c60 100644
int chroma_qp[2]; // QPc int chroma_qp[2]; // QPc
int qp_thresh; ///< QP threshold to skip loopfilter int qp_thresh; ///< QP threshold to skip loopfilter
diff --git a/libavcodec/v4l2_request_h264.c b/libavcodec/v4l2_request_h264.c 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 --- a/libavcodec/v4l2_request_h264.c
+++ b/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, .pic_parameter_set_id = sl->pps_id,
.colour_plane_id = 0, /* what is this? */ .colour_plane_id = 0, /* what is this? */
.frame_num = h->poc.frame_num, .frame_num = h->poc.frame_num,
@ -49,3 +49,6 @@ index b826c9d356..a49773b228 100644
.pic_order_cnt_lsb = sl->poc_lsb, .pic_order_cnt_lsb = sl->poc_lsb,
.delta_pic_order_cnt_bottom = sl->delta_poc_bottom, .delta_pic_order_cnt_bottom = sl->delta_poc_bottom,
.delta_pic_order_cnt0 = sl->delta_poc[0], .delta_pic_order_cnt0 = sl->delta_poc[0],
--
2.24.0

11
packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0010-avcodec-h264-parse-ref_pic_marking_size_in_bits-and-.patch
View File

@ -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 <boris.brezillon@collabora.com> From: Boris Brezillon <boris.brezillon@collabora.com>
Date: Wed, 22 May 2019 14:44:22 +0200 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 pic_order_cnt_bit_size
Signed-off-by: Boris Brezillon <boris.brezillon@collabora.com> Signed-off-by: Boris Brezillon <boris.brezillon@collabora.com>
@ -71,10 +71,10 @@ index 38efab5c60..8e894f565b 100644
int max_pic_num; int max_pic_num;
} H264SliceContext; } H264SliceContext;
diff --git a/libavcodec/v4l2_request_h264.c b/libavcodec/v4l2_request_h264.c 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 --- a/libavcodec/v4l2_request_h264.c
+++ b/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, .redundant_pic_cnt = sl->redundant_pic_count,
/* Size in bits of dec_ref_pic_marking() syntax element. */ /* 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, .cabac_init_idc = sl->cabac_init_idc,
.slice_qp_delta = sl->qscale - pps->init_qp, .slice_qp_delta = sl->qscale - pps->init_qp,
--
2.24.0

14
packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0011-HACK-add-dpb-flags-for-reference-usage-and-field-pic.patch
View File

@ -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 <jonas@kwiboo.se> From: Jonas Karlman <jonas@kwiboo.se>
Date: Fri, 24 May 2019 22:58:24 +0000 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 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 { struct v4l2_h264_dpb_entry {
__u64 reference_ts; __u64 reference_ts;
diff --git a/libavcodec/v4l2_request_h264.c b/libavcodec/v4l2_request_h264.c 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 --- a/libavcodec/v4l2_request_h264.c
+++ b/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->frame_num = pic->frame_num;
entry->pic_num = pic->pic_id; entry->pic_num = pic->pic_id;
entry->flags = V4L2_H264_DPB_ENTRY_FLAG_VALID; entry->flags = V4L2_H264_DPB_ENTRY_FLAG_VALID;
@ -44,7 +45,7 @@ index 229df6969d..7f345b1955 100644
if (pic->field_poc[0] != INT_MAX) if (pic->field_poc[0] != INT_MAX)
entry->top_field_order_cnt = pic->field_poc[0]; entry->top_field_order_cnt = pic->field_poc[0];
if (pic->field_poc[1] != INT_MAX) 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]; struct v4l2_h264_dpb_entry *entry = &decode->dpb[i];
if ((entry->flags & V4L2_H264_DPB_ENTRY_FLAG_VALID) && if ((entry->flags & V4L2_H264_DPB_ENTRY_FLAG_VALID) &&
entry->reference_ts == timestamp) entry->reference_ts == timestamp)
@ -54,3 +55,6 @@ index 229df6969d..7f345b1955 100644
} }
return 0; return 0;
--
2.24.0

72
packages/multimedia/ffmpeg/patches/v4l2-request-api/ffmpeg-95.0012-WIP-v4l2-request-rolling-timestamps.patch Normal file
View File

@ -0,0 +1,72 @@
From a205c82e430dafd90485b804ce40c1b42cbf9edf Mon Sep 17 00:00:00 2001
From: Jernej Skrabec <jernej.skrabec@siol.net>
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