From patchwork Thu Dec 2 15:16:29 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Daniel Almeida X-Patchwork-Id: 520008 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id B2B87C433FE for ; Thu, 2 Dec 2021 15:16:55 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1358916AbhLBPUR (ORCPT ); Thu, 2 Dec 2021 10:20:17 -0500 Received: from bhuna.collabora.co.uk ([46.235.227.227]:48352 "EHLO bhuna.collabora.co.uk" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1358901AbhLBPUM (ORCPT ); Thu, 2 Dec 2021 10:20:12 -0500 Received: from localhost.localdomain (unknown [IPv6:2804:14d:72b4:9077:b53b:d2e6:63a5:6035]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) (Authenticated sender: dwlsalmeida) by bhuna.collabora.co.uk (Postfix) with ESMTPSA id 6967D1F4672F; Thu, 2 Dec 2021 15:16:46 +0000 (GMT) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=collabora.com; s=mail; t=1638458207; bh=E7sanbHGhplUhs/1OgS65v06h7V2JHSMEjiZbTLMPNE=; h=From:To:Cc:Subject:Date:From; b=OVgfL6Ax8hutSBsV8DBO4A5bx9HbRCj4B/amQJu6CphErpG8gjjFrEtujk6QvofeP xEUCIMIIOm4+1sMI7yZ3s02Jh79YKPUY4E9GtYvh5tJ3MpitU2U4mu77E/SJ4/mqZz 0NpNIBP9foa1tH6ZVnW3BWEERtUhESCOgKfUVzdFRHLHtA/sM7NbX43tRio8Pj5TfD D02Z2VPlDWo4Aba+PImHmSZKF2BZa80glXQHB+TSv2YtC9r5tH3UyOvSNneIeKKG8W ZrnbI+Pf2I0+BwQajsUs8ogvPXzHBWy3FLOJCxZUvCCTGpVDbmpNBq1MOh8mBVHZHF KHt4pFnlWVo1Q== From: daniel.almeida@collabora.com To: hverkuil@xs4all.nl Cc: Daniel Almeida , linux-media@vger.kernel.org, Ezequiel Garcia Subject: [RFC PATCH] Implement a POC for V4L2 stateless uAPI versioning Date: Thu, 2 Dec 2021 12:16:29 -0300 Message-Id: <20211202151629.581818-1-daniel.almeida@collabora.com> X-Mailer: git-send-email 2.34.0 MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-media@vger.kernel.org From: Daniel Almeida Signed-off-by: Daniel Almeida Suggested-by: Ezequiel Garcia --- Hi all. This is a proposal to enable versioning of the stateless uAPIs so as to allow multiple versions to coexist in the kernel. It was initially suggested by Ezequiel Garcia. The problem: Without any form of versioning in place, utmost care must be taken before merging uAPI code, since it is considered final and "set in stone". This naturally slows down progress of uAPI development as we expect each codec uAPI to be more or less perfect before merging it. Arguably, this is an unrealistic expectation and VP9, for instance, had to be substantially reworked as of the introduction of V4L2_STATELESS_CID_COMPRESSED_HDR. The proposed solution: This patch attempts to address the problem by introducing a menu control to query/get/set API version. Once the API version is set, the core/driver will use the set of corresponding structs. You can see how this looks like with one of the simplest codecs we support, i.e. MPEG2. A driver can specify what versions of the uAPI it can work with by means of its try_ctrl() hook if the standard min/max validation for menu controls is not enough. It is then shown how this can work with Hantro G1, but note that V2 is simply a copy of V1 in this example. I have also worked on an tentative userspace implementation using gstreamer[0]. A user can then select which version of the uAPI she wants to use by means of a property, which case the application will try to validate the chosen version first. There are four outcomes possible when negotiating the version to be used: a) If the VIDIOC_G_EXT_CTRLS ioctl for the version menu control fails, we assume that the driver does not support versioning and we default to v1. b) If the VIDIOC_G_EXT_CTRLS ioctl for the version menu control succeeds, we store the default value as reported by the driver. c) We attempt to set the version the user passed in, if that does not match the default, and if that fails, d) We check if we support the default as returned by the driver, and if not, we error out. Pros: This approach can be used on top of the existing controls, i.e. it can be used to extend drivers and still support old kernels backwards. If the control V4L2_CID_STATELESS_{}_VERSION is not present on a given driver, applications can safely assume the first API version is the only supported. The version suffix (i.e. _v1) on structs is not needed as it is assumed that no suffix effectively means v1. uAPI development can be streamlined as developers will know these can further be extended in the future if some hardware is incompatible with the current versions. Design mistakes will not be catastrophic, instead they can be elegantly solved in a newer version. Version negotiation is easy from a userspace perspective, applications can indicate a preference for the version number. Drops the use of "reserved" for future APIs. If the number of versions is kept to a minimum (i.e. v2, v3, at most v4) then it is very tractable. Cons: Applications will need to support different versions as they come out. The version applies to the entire API, not control-wise. In a sense, under this design, some repetition is the price to pay for tidiness. This approach is less-ambiguous and therefore less error-prone. Closing thoughts: This is only a draft, but I hope this design is enough to kickstart some discussion around this topic. [0]: https://gitlab.freedesktop.org/dwlsalmeida/gstreamer/-/merge_requests/1/commits --- drivers/media/v4l2-core/v4l2-ctrls-core.c | 67 +++++++++++++++++++ drivers/media/v4l2-core/v4l2-ctrls-defs.c | 21 ++++++ drivers/staging/media/hantro/hantro_drv.c | 28 ++++++++ .../media/hantro/hantro_g1_mpeg2_dec.c | 47 +++++++++++-- include/media/v4l2-ctrls.h | 3 + include/uapi/linux/v4l2-controls.h | 38 +++++++++++ include/uapi/linux/videodev2.h | 7 ++ 7 files changed, 207 insertions(+), 4 deletions(-) diff --git a/drivers/media/v4l2-core/v4l2-ctrls-core.c b/drivers/media/v4l2-core/v4l2-ctrls-core.c index 54abe5245dcc..a821ed4d458d 100644 --- a/drivers/media/v4l2-core/v4l2-ctrls-core.c +++ b/drivers/media/v4l2-core/v4l2-ctrls-core.c @@ -283,6 +283,15 @@ static void std_log(const struct v4l2_ctrl *ctrl) case V4L2_CTRL_TYPE_MPEG2_PICTURE: pr_cont("MPEG2_PICTURE"); break; + case V4L2_CTRL_TYPE_MPEG2_QUANTISATION_V2: + pr_cont("MPEG2_QUANTISATION_V2"); + break; + case V4L2_CTRL_TYPE_MPEG2_SEQUENCE_V2: + pr_cont("MPEG2_SEQUENCE_V2"); + break; + case V4L2_CTRL_TYPE_MPEG2_PICTURE_V2: + pr_cont("MPEG2_PICTURE_V2"); + break; case V4L2_CTRL_TYPE_VP9_COMPRESSED_HDR: pr_cont("VP9_COMPRESSED_HDR"); break; @@ -559,6 +568,55 @@ static int std_validate_compound(const struct v4l2_ctrl *ctrl, u32 idx, case V4L2_CTRL_TYPE_MPEG2_QUANTISATION: break; + case V4L2_CTRL_TYPE_MPEG2_SEQUENCE_V2: + p_mpeg2_sequence = p; + + switch (p_mpeg2_sequence->chroma_format) { + case 1: /* 4:2:0 */ + case 2: /* 4:2:2 */ + case 3: /* 4:4:4 */ + break; + default: + return -EINVAL; + } + break; + + case V4L2_CTRL_TYPE_MPEG2_PICTURE_V2: + p_mpeg2_picture = p; + + switch (p_mpeg2_picture->intra_dc_precision) { + case 0: /* 8 bits */ + case 1: /* 9 bits */ + case 2: /* 10 bits */ + case 3: /* 11 bits */ + break; + default: + return -EINVAL; + } + + switch (p_mpeg2_picture->picture_structure) { + case V4L2_MPEG2_PIC_TOP_FIELD: + case V4L2_MPEG2_PIC_BOTTOM_FIELD: + case V4L2_MPEG2_PIC_FRAME: + break; + default: + return -EINVAL; + } + + switch (p_mpeg2_picture->picture_coding_type) { + case V4L2_MPEG2_PIC_CODING_TYPE_I: + case V4L2_MPEG2_PIC_CODING_TYPE_P: + case V4L2_MPEG2_PIC_CODING_TYPE_B: + break; + default: + return -EINVAL; + } + zero_reserved(*p_mpeg2_picture); + break; + + case V4L2_CTRL_TYPE_MPEG2_QUANTISATION_V2: + break; + case V4L2_CTRL_TYPE_FWHT_PARAMS: p_fwht_params = p; @@ -1384,6 +1442,15 @@ static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl, case V4L2_CTRL_TYPE_MPEG2_QUANTISATION: elem_size = sizeof(struct v4l2_ctrl_mpeg2_quantisation); break; + case V4L2_CTRL_TYPE_MPEG2_SEQUENCE_V2: + elem_size = sizeof(struct v4l2_ctrl_mpeg2_sequence_v2); + break; + case V4L2_CTRL_TYPE_MPEG2_PICTURE_V2: + elem_size = sizeof(struct v4l2_ctrl_mpeg2_picture_v2); + break; + case V4L2_CTRL_TYPE_MPEG2_QUANTISATION_V2: + elem_size = sizeof(struct v4l2_ctrl_mpeg2_quantisation_v2); + break; case V4L2_CTRL_TYPE_FWHT_PARAMS: elem_size = sizeof(struct v4l2_ctrl_fwht_params); break; diff --git a/drivers/media/v4l2-core/v4l2-ctrls-defs.c b/drivers/media/v4l2-core/v4l2-ctrls-defs.c index 54ca4e6b820b..b487f0c3fa3f 100644 --- a/drivers/media/v4l2-core/v4l2-ctrls-defs.c +++ b/drivers/media/v4l2-core/v4l2-ctrls-defs.c @@ -573,6 +573,11 @@ const char * const *v4l2_ctrl_get_menu(u32 id) NULL, }; + static const char * const mpeg2_stateless_uapi_version[] = { + "V1", + "V2", + }; + switch (id) { case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: return mpeg_audio_sampling_freq; @@ -705,6 +710,8 @@ const char * const *v4l2_ctrl_get_menu(u32 id) return hevc_start_code; case V4L2_CID_CAMERA_ORIENTATION: return camera_orientation; + case V4L2_CID_STATELESS_MPEG2_UAPI_VERSION: + return mpeg2_stateless_uapi_version; default: return NULL; } @@ -1178,6 +1185,10 @@ const char *v4l2_ctrl_get_name(u32 id) case V4L2_CID_STATELESS_MPEG2_SEQUENCE: return "MPEG-2 Sequence Header"; case V4L2_CID_STATELESS_MPEG2_PICTURE: return "MPEG-2 Picture Header"; case V4L2_CID_STATELESS_MPEG2_QUANTISATION: return "MPEG-2 Quantisation Matrices"; + case V4L2_CID_STATELESS_MPEG2_SEQUENCE_V2: return "MPEG-2 Sequence Header V2"; + case V4L2_CID_STATELESS_MPEG2_PICTURE_V2: return "MPEG-2 Picture Header V2"; + case V4L2_CID_STATELESS_MPEG2_QUANTISATION_V2: return "MPEG-2 Quantisation Matrices V2"; + case V4L2_CID_STATELESS_MPEG2_UAPI_VERSION: return "MPEG-2 uAPI Version"; case V4L2_CID_STATELESS_VP9_COMPRESSED_HDR: return "VP9 Probabilities Updates"; case V4L2_CID_STATELESS_VP9_FRAME: return "VP9 Frame Decode Parameters"; @@ -1360,6 +1371,7 @@ void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type, case V4L2_CID_STATELESS_H264_DECODE_MODE: case V4L2_CID_STATELESS_H264_START_CODE: case V4L2_CID_CAMERA_ORIENTATION: + case V4L2_CID_STATELESS_MPEG2_UAPI_VERSION: *type = V4L2_CTRL_TYPE_MENU; break; case V4L2_CID_LINK_FREQ: @@ -1469,6 +1481,15 @@ void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type, case V4L2_CID_STATELESS_MPEG2_QUANTISATION: *type = V4L2_CTRL_TYPE_MPEG2_QUANTISATION; break; + case V4L2_CID_STATELESS_MPEG2_SEQUENCE_V2: + *type = V4L2_CTRL_TYPE_MPEG2_SEQUENCE_V2; + break; + case V4L2_CID_STATELESS_MPEG2_PICTURE_V2: + *type = V4L2_CTRL_TYPE_MPEG2_PICTURE_V2; + break; + case V4L2_CID_STATELESS_MPEG2_QUANTISATION_V2: + *type = V4L2_CTRL_TYPE_MPEG2_QUANTISATION_V2; + break; case V4L2_CID_STATELESS_FWHT_PARAMS: *type = V4L2_CTRL_TYPE_FWHT_PARAMS; break; diff --git a/drivers/staging/media/hantro/hantro_drv.c b/drivers/staging/media/hantro/hantro_drv.c index ab2467998d29..036810db1d67 100644 --- a/drivers/staging/media/hantro/hantro_drv.c +++ b/drivers/staging/media/hantro/hantro_drv.c @@ -269,6 +269,11 @@ static int hantro_try_ctrl(struct v4l2_ctrl *ctrl) /* We only support profile 0 */ if (dec_params->profile != 0) return -EINVAL; + } else if (ctrl->id == V4L2_CID_STATELESS_MPEG2_UAPI_VERSION) { + /* + * optionally restrict the uAPI version that this driver supports if + * the standard min/max validation for menu controls is not enough + */ } return 0; } @@ -336,6 +341,14 @@ static const struct hantro_ctrl controls[] = { .def = 50, .ops = &hantro_jpeg_ctrl_ops, }, + }, { + .codec = HANTRO_MPEG2_DECODER, + .cfg = { + .id = V4L2_CID_STATELESS_MPEG2_UAPI_VERSION, + .def = V4L2_STATELESS_MPEG2_UAPI_V1, + .min = V4L2_STATELESS_MPEG2_UAPI_V1, + .max = V4L2_STATELESS_MPEG2_UAPI_V2, + }, }, { .codec = HANTRO_MPEG2_DECODER, .cfg = { @@ -351,6 +364,21 @@ static const struct hantro_ctrl controls[] = { .cfg = { .id = V4L2_CID_STATELESS_MPEG2_QUANTISATION, }, + }, { + .codec = HANTRO_MPEG2_DECODER, + .cfg = { + .id = V4L2_CID_STATELESS_MPEG2_SEQUENCE_V2, + }, + }, { + .codec = HANTRO_MPEG2_DECODER, + .cfg = { + .id = V4L2_CID_STATELESS_MPEG2_PICTURE_V2, + }, + }, { + .codec = HANTRO_MPEG2_DECODER, + .cfg = { + .id = V4L2_CID_STATELESS_MPEG2_QUANTISATION_V2, + }, }, { .codec = HANTRO_VP8_DECODER, .cfg = { diff --git a/drivers/staging/media/hantro/hantro_g1_mpeg2_dec.c b/drivers/staging/media/hantro/hantro_g1_mpeg2_dec.c index 9aea331e1a3c..7c209efa0b8e 100644 --- a/drivers/staging/media/hantro/hantro_g1_mpeg2_dec.c +++ b/drivers/staging/media/hantro/hantro_g1_mpeg2_dec.c @@ -145,7 +145,7 @@ hantro_g1_mpeg2_dec_set_buffers(struct hantro_dev *vpu, struct hantro_ctx *ctx, vdpu_write_relaxed(vpu, backward_addr, G1_REG_REFER3_BASE); } -int hantro_g1_mpeg2_dec_run(struct hantro_ctx *ctx) +static void hantro_g1_mpeg2_dec_run_v1(struct hantro_ctx *ctx) { struct hantro_dev *vpu = ctx->dev; struct vb2_v4l2_buffer *src_buf, *dst_buf; @@ -156,9 +156,6 @@ int hantro_g1_mpeg2_dec_run(struct hantro_ctx *ctx) src_buf = hantro_get_src_buf(ctx); dst_buf = hantro_get_dst_buf(ctx); - /* Apply request controls if any */ - hantro_start_prepare_run(ctx); - seq = hantro_get_ctrl(ctx, V4L2_CID_STATELESS_MPEG2_SEQUENCE); pic = hantro_get_ctrl(ctx, @@ -231,6 +228,48 @@ int hantro_g1_mpeg2_dec_run(struct hantro_ctx *ctx) hantro_g1_mpeg2_dec_set_buffers(vpu, ctx, &src_buf->vb2_buf, &dst_buf->vb2_buf, seq, pic); +} + +static void hantro_g1_mpeg2_dec_run_v2(struct hantro_ctx *ctx) +{ + const struct v4l2_ctrl_mpeg2_sequence_v2 *seq; + const struct v4l2_ctrl_mpeg2_picture_v2 *pic; + const struct v4l2_ctrl_mpeg2_quantisation_v2 *quant; + + seq = hantro_get_ctrl(ctx, + V4L2_CID_STATELESS_MPEG2_SEQUENCE_V2); + pic = hantro_get_ctrl(ctx, + V4L2_CID_STATELESS_MPEG2_PICTURE_V2); + quant = hantro_get_ctrl(ctx, + V4L2_CID_STATELESS_MPEG2_QUANTISATION_V2); + + WARN_ON_ONCE(!seq || !pic || !quant); + + /* actually implement v2 ... */ + + /* pretend this happened so as to keep userspace going */ + hantro_irq_done(ctx->dev, VB2_BUF_STATE_DONE); +} + +int hantro_g1_mpeg2_dec_run(struct hantro_ctx *ctx) +{ + struct hantro_dev *vpu = ctx->dev; + enum v4l2_stateless_mpeg2_uapi_version version; + + /* Apply request controls if any */ + hantro_start_prepare_run(ctx); + + version = v4l2_ctrl_find(&ctx->ctrl_handler, + V4L2_CID_STATELESS_MPEG2_UAPI_VERSION)->cur.val; + + switch (version) { + case V4L2_STATELESS_MPEG2_UAPI_V1: + hantro_g1_mpeg2_dec_run_v1(ctx); + break; + case V4L2_STATELESS_MPEG2_UAPI_V2: + hantro_g1_mpeg2_dec_run_v2(ctx); + break; + } hantro_end_prepare_run(ctx); diff --git a/include/media/v4l2-ctrls.h b/include/media/v4l2-ctrls.h index b3ce438f1329..57f11bf4a516 100644 --- a/include/media/v4l2-ctrls.h +++ b/include/media/v4l2-ctrls.h @@ -71,6 +71,9 @@ union v4l2_ctrl_ptr { struct v4l2_ctrl_mpeg2_sequence *p_mpeg2_sequence; struct v4l2_ctrl_mpeg2_picture *p_mpeg2_picture; struct v4l2_ctrl_mpeg2_quantisation *p_mpeg2_quantisation; + struct v4l2_ctrl_mpeg2_sequence_v2 *p_mpeg2_sequence_v2; + struct v4l2_ctrl_mpeg2_picture_v2 *p_mpeg2_picture_v2; + struct v4l2_ctrl_mpeg2_quantisation_v2 *p_mpeg2_quantisation_v2; struct v4l2_ctrl_fwht_params *p_fwht_params; struct v4l2_ctrl_h264_sps *p_h264_sps; struct v4l2_ctrl_h264_pps *p_h264_pps; diff --git a/include/uapi/linux/v4l2-controls.h b/include/uapi/linux/v4l2-controls.h index c8e0f84d204d..a4a990e16603 100644 --- a/include/uapi/linux/v4l2-controls.h +++ b/include/uapi/linux/v4l2-controls.h @@ -1984,6 +1984,44 @@ struct v4l2_ctrl_mpeg2_quantisation { __u8 chroma_non_intra_quantiser_matrix[64]; }; +#define V4L2_CID_STATELESS_MPEG2_UAPI_VERSION (V4L2_CID_CODEC_STATELESS_BASE+223) + +enum v4l2_stateless_mpeg2_uapi_version { + V4L2_STATELESS_MPEG2_UAPI_V1, /* assume V1 by default */ + V4L2_STATELESS_MPEG2_UAPI_V2, +}; + +#define V4L2_CID_STATELESS_MPEG2_QUANTISATION_V2 (V4L2_CID_CODEC_STATELESS_BASE+224) +#define V4L2_CID_STATELESS_MPEG2_PICTURE_V2 (V4L2_CID_CODEC_STATELESS_BASE+225) +#define V4L2_CID_STATELESS_MPEG2_SEQUENCE_V2 (V4L2_CID_CODEC_STATELESS_BASE+226) + +struct v4l2_ctrl_mpeg2_quantisation_v2 { + __u8 intra_quantiser_matrix[64]; + __u8 non_intra_quantiser_matrix[64]; + __u8 chroma_intra_quantiser_matrix[64]; + __u8 chroma_non_intra_quantiser_matrix[64]; +}; + +struct v4l2_ctrl_mpeg2_picture_v2 { + __u64 backward_ref_ts; + __u64 forward_ref_ts; + __u32 flags; + __u8 f_code[2][2]; + __u8 picture_coding_type; + __u8 picture_structure; + __u8 intra_dc_precision; + __u8 reserved[5]; +}; + +struct v4l2_ctrl_mpeg2_sequence_v2 { + __u16 horizontal_size; + __u16 vertical_size; + __u32 vbv_buffer_size; + __u16 profile_and_level_indication; + __u8 chroma_format; + __u8 flags; +}; + #define V4L2_CID_COLORIMETRY_CLASS_BASE (V4L2_CTRL_CLASS_COLORIMETRY | 0x900) #define V4L2_CID_COLORIMETRY_CLASS (V4L2_CTRL_CLASS_COLORIMETRY | 1) diff --git a/include/uapi/linux/videodev2.h b/include/uapi/linux/videodev2.h index df8b9c486ba1..178e8acf8bbf 100644 --- a/include/uapi/linux/videodev2.h +++ b/include/uapi/linux/videodev2.h @@ -1760,6 +1760,10 @@ struct v4l2_ext_control { struct v4l2_ctrl_mpeg2_sequence __user *p_mpeg2_sequence; struct v4l2_ctrl_mpeg2_picture __user *p_mpeg2_picture; struct v4l2_ctrl_mpeg2_quantisation __user *p_mpeg2_quantisation; + struct v4l2_ctrl_mpeg2_sequence_v2 __user *p_mpeg2_sequence_v2; + struct v4l2_ctrl_mpeg2_picture_v2 __user *p_mpeg2_picture_v2; + struct v4l2_ctrl_mpeg2_quantisation_v2 __user *p_mpeg2_quantisation_v2; + struct v4l2_ctrl_mpeg2_uapi_version __user *p_mpeg2_uapi_version; struct v4l2_ctrl_vp9_compressed_hdr __user *p_vp9_compressed_hdr_probs; struct v4l2_ctrl_vp9_frame __user *p_vp9_frame; void __user *ptr; @@ -1826,6 +1830,9 @@ enum v4l2_ctrl_type { V4L2_CTRL_TYPE_MPEG2_QUANTISATION = 0x0250, V4L2_CTRL_TYPE_MPEG2_SEQUENCE = 0x0251, V4L2_CTRL_TYPE_MPEG2_PICTURE = 0x0252, + V4L2_CTRL_TYPE_MPEG2_QUANTISATION_V2 = 0x0253, + V4L2_CTRL_TYPE_MPEG2_SEQUENCE_V2 = 0x0254, + V4L2_CTRL_TYPE_MPEG2_PICTURE_V2 = 0x0255, V4L2_CTRL_TYPE_VP9_COMPRESSED_HDR = 0x0260, V4L2_CTRL_TYPE_VP9_FRAME = 0x0261,