From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 426BEC10F11 for ; Wed, 10 Apr 2019 13:44:40 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id EE61F20830 for ; Wed, 10 Apr 2019 13:44:39 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731568AbfDJNoi (ORCPT ); Wed, 10 Apr 2019 09:44:38 -0400 Received: from relay3-d.mail.gandi.net ([217.70.183.195]:55463 "EHLO relay3-d.mail.gandi.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728787AbfDJNoi (ORCPT ); Wed, 10 Apr 2019 09:44:38 -0400 X-Originating-IP: 90.88.18.121 Received: from aptenodytes (aaubervilliers-681-1-63-121.w90-88.abo.wanadoo.fr [90.88.18.121]) (Authenticated sender: paul.kocialkowski@bootlin.com) by relay3-d.mail.gandi.net (Postfix) with ESMTPSA id B2FE260010; Wed, 10 Apr 2019 13:44:28 +0000 (UTC) Message-ID: Subject: Re: [PATCH v8 1/2] media: uapi: Add H264 low-level decoder API compound controls. From: Paul Kocialkowski To: Maxime Ripard , hans.verkuil@cisco.com, acourbot@chromium.org, sakari.ailus@linux.intel.com, Laurent Pinchart Cc: tfiga@chromium.org, posciak@chromium.org, Chen-Yu Tsai , linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-media@vger.kernel.org, nicolas.dufresne@collabora.com, jenskuske@gmail.com, jernej.skrabec@gmail.com, jonas@kwiboo.se, ezequiel@collabora.com, linux-sunxi@googlegroups.com, Thomas Petazzoni , Guenter Roeck Date: Wed, 10 Apr 2019 15:44:28 +0200 In-Reply-To: References: Organization: Bootlin Content-Type: text/plain; charset="UTF-8" User-Agent: Evolution 3.32.0 MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi, Le jeudi 04 avril 2019 à 14:59 +0200, Maxime Ripard a écrit : > From: Pawel Osciak > > Stateless video codecs will require both the H264 metadata and slices in > order to be able to decode frames. > > This introduces the definitions for a new pixel format for H264 slices that > have been parsed, as well as the structures used to pass the metadata from > the userspace to the kernel. With V4L2_PIX_FMT_H264_SLICE_RAW renamed to V4L2_PIX_FMT_H264_SLICE and moved to the private h264-ctrls.h, this is: Reviewed-by: Paul Kocialkowski Cheers, Paul > Reviewed-by: Tomasz Figa > Signed-off-by: Pawel Osciak > Signed-off-by: Guenter Roeck > Co-developed-by: Maxime Ripard > Signed-off-by: Maxime Ripard > --- > Documentation/media/uapi/v4l/biblio.rst | 9 +- > Documentation/media/uapi/v4l/ext-ctrls-codec.rst | 569 ++++++++++++++- > Documentation/media/uapi/v4l/pixfmt-compressed.rst | 19 +- > Documentation/media/uapi/v4l/vidioc-queryctrl.rst | 30 +- > Documentation/media/videodev2.h.rst.exceptions | 5 +- > drivers/media/v4l2-core/v4l2-ctrls.c | 42 +- > drivers/media/v4l2-core/v4l2-ioctl.c | 1 +- > include/media/h264-ctrls.h | 192 +++++- > include/media/v4l2-ctrls.h | 13 +- > include/uapi/linux/videodev2.h | 1 +- > 10 files changed, 880 insertions(+), 1 deletion(-) > create mode 100644 include/media/h264-ctrls.h > > diff --git a/Documentation/media/uapi/v4l/biblio.rst b/Documentation/media/uapi/v4l/biblio.rst > index ec33768c055e..8f4eb8823d82 100644 > --- a/Documentation/media/uapi/v4l/biblio.rst > +++ b/Documentation/media/uapi/v4l/biblio.rst > @@ -122,6 +122,15 @@ ITU BT.1119 > > :author: International Telecommunication Union (http://www.itu.ch) > > +.. _h264: > + > +ITU-T Rec. H.264 Specification (04/2017 Edition) > +================================================ > + > +:title: ITU-T Recommendation H.264 "Advanced Video Coding for Generic Audiovisual Services" > + > +:author: International Telecommunication Union (http://www.itu.ch) > + > .. _jfif: > > JFIF > diff --git a/Documentation/media/uapi/v4l/ext-ctrls-codec.rst b/Documentation/media/uapi/v4l/ext-ctrls-codec.rst > index 67a122339c0e..fe720f239f70 100644 > --- a/Documentation/media/uapi/v4l/ext-ctrls-codec.rst > +++ b/Documentation/media/uapi/v4l/ext-ctrls-codec.rst > @@ -1371,6 +1371,575 @@ enum v4l2_mpeg_video_h264_hierarchical_coding_type - > - Layer number > > > +.. _v4l2-mpeg-h264: > + > +``V4L2_CID_MPEG_VIDEO_H264_SPS (struct)`` > + Specifies the sequence parameter set (as extracted from the > + bitstream) for the associated H264 slice data. This includes the > + necessary parameters for configuring a stateless hardware decoding > + pipeline for H264. The bitstream parameters are defined according > + to :ref:`h264`, section 7.4.2.1.1 "Sequence Parameter Set Data > + Semantics". For further documentation, refer to the above > + specification, unless there is an explicit comment stating > + otherwise. > + > + .. note:: > + > + This compound control is not yet part of the public kernel API and > + it is expected to change. > + > +.. c:type:: v4l2_ctrl_h264_sps > + > +.. cssclass:: longtable > + > +.. flat-table:: struct v4l2_ctrl_h264_sps > + :header-rows: 0 > + :stub-columns: 0 > + :widths: 1 1 2 > + > + * - __u8 > + - ``profile_idc`` > + - > + * - __u8 > + - ``constraint_set_flags`` > + - See :ref:`Sequence Parameter Set Constraints Set Flags ` > + * - __u8 > + - ``level_idc`` > + - > + * - __u8 > + - ``seq_parameter_set_id`` > + - > + * - __u8 > + - ``chroma_format_idc`` > + - > + * - __u8 > + - ``bit_depth_luma_minus8`` > + - > + * - __u8 > + - ``bit_depth_chroma_minus8`` > + - > + * - __u8 > + - ``log2_max_frame_num_minus4`` > + - > + * - __u8 > + - ``pic_order_cnt_type`` > + - > + * - __u8 > + - ``log2_max_pic_order_cnt_lsb_minus4`` > + - > + * - __u8 > + - ``max_num_ref_frames`` > + - > + * - __u8 > + - ``num_ref_frames_in_pic_order_cnt_cycle`` > + - > + * - __s32 > + - ``offset_for_ref_frame[255]`` > + - > + * - __s32 > + - ``offset_for_non_ref_pic`` > + - > + * - __s32 > + - ``offset_for_top_to_bottom_field`` > + - > + * - __u16 > + - ``pic_width_in_mbs_minus1`` > + - > + * - __u16 > + - ``pic_height_in_map_units_minus1`` > + - > + * - __u32 > + - ``flags`` > + - See :ref:`Sequence Parameter Set Flags ` > + > +.. _h264_sps_constraints_set_flags: > + > +``Sequence Parameter Set Constraints Set Flags`` > + > +.. cssclass:: longtable > + > +.. flat-table:: > + :header-rows: 0 > + :stub-columns: 0 > + :widths: 1 1 2 > + > + * - ``V4L2_H264_SPS_CONSTRAINT_SET0_FLAG`` > + - 0x00000001 > + - > + * - ``V4L2_H264_SPS_CONSTRAINT_SET1_FLAG`` > + - 0x00000002 > + - > + * - ``V4L2_H264_SPS_CONSTRAINT_SET2_FLAG`` > + - 0x00000004 > + - > + * - ``V4L2_H264_SPS_CONSTRAINT_SET3_FLAG`` > + - 0x00000008 > + - > + * - ``V4L2_H264_SPS_CONSTRAINT_SET4_FLAG`` > + - 0x00000010 > + - > + * - ``V4L2_H264_SPS_CONSTRAINT_SET5_FLAG`` > + - 0x00000020 > + - > + > +.. _h264_sps_flags: > + > +``Sequence Parameter Set Flags`` > + > +.. cssclass:: longtable > + > +.. flat-table:: > + :header-rows: 0 > + :stub-columns: 0 > + :widths: 1 1 2 > + > + * - ``V4L2_H264_SPS_FLAG_SEPARATE_COLOUR_PLANE`` > + - 0x00000001 > + - > + * - ``V4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASS`` > + - 0x00000002 > + - > + * - ``V4L2_H264_SPS_FLAG_DELTA_PIC_ORDER_ALWAYS_ZERO`` > + - 0x00000004 > + - > + * - ``V4L2_H264_SPS_FLAG_GAPS_IN_FRAME_NUM_VALUE_ALLOWED`` > + - 0x00000008 > + - > + * - ``V4L2_H264_SPS_FLAG_FRAME_MBS_ONLY`` > + - 0x00000010 > + - > + * - ``V4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELD`` > + - 0x00000020 > + - > + * - ``V4L2_H264_SPS_FLAG_DIRECT_8X8_INFERENCE`` > + - 0x00000040 > + - > + > +``V4L2_CID_MPEG_VIDEO_H264_PPS (struct)`` > + Specifies the picture parameter set (as extracted from the > + bitstream) for the associated H264 slice data. This includes the > + necessary parameters for configuring a stateless hardware decoding > + pipeline for H264. The bitstream parameters are defined according > + to :ref:`h264`, section 7.4.2.2 "Picture Parameter Set RBSP > + Semantics". For further documentation, refer to the above > + specification, unless there is an explicit comment stating > + otherwise. > + > + .. note:: > + > + This compound control is not yet part of the public kernel API and > + it is expected to change. > + > +.. c:type:: v4l2_ctrl_h264_pps > + > +.. cssclass:: longtable > + > +.. flat-table:: struct v4l2_ctrl_h264_pps > + :header-rows: 0 > + :stub-columns: 0 > + :widths: 1 1 2 > + > + * - __u8 > + - ``pic_parameter_set_id`` > + - > + * - __u8 > + - ``seq_parameter_set_id`` > + - > + * - __u8 > + - ``num_slice_groups_minus1`` > + - > + * - __u8 > + - ``num_ref_idx_l0_default_active_minus1`` > + - > + * - __u8 > + - ``num_ref_idx_l1_default_active_minus1`` > + - > + * - __u8 > + - ``weighted_bipred_idc`` > + - > + * - __s8 > + - ``pic_init_qp_minus26`` > + - > + * - __s8 > + - ``pic_init_qs_minus26`` > + - > + * - __s8 > + - ``chroma_qp_index_offset`` > + - > + * - __s8 > + - ``second_chroma_qp_index_offset`` > + - > + * - __u16 > + - ``flags`` > + - See :ref:`Picture Parameter Set Flags ` > + > +.. _h264_pps_flags: > + > +``Picture Parameter Set Flags`` > + > +.. cssclass:: longtable > + > +.. flat-table:: > + :header-rows: 0 > + :stub-columns: 0 > + :widths: 1 1 2 > + > + * - ``V4L2_H264_PPS_FLAG_ENTROPY_CODING_MODE`` > + - 0x00000001 > + - > + * - ``V4L2_H264_PPS_FLAG_BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENT`` > + - 0x00000002 > + - > + * - ``V4L2_H264_PPS_FLAG_WEIGHTED_PRED`` > + - 0x00000004 > + - > + * - ``V4L2_H264_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT`` > + - 0x00000008 > + - > + * - ``V4L2_H264_PPS_FLAG_CONSTRAINED_INTRA_PRED`` > + - 0x00000010 > + - > + * - ``V4L2_H264_PPS_FLAG_REDUNDANT_PIC_CNT_PRESENT`` > + - 0x00000020 > + - > + * - ``V4L2_H264_PPS_FLAG_TRANSFORM_8X8_MODE`` > + - 0x00000040 > + - > + * - ``V4L2_H264_PPS_FLAG_PIC_SCALING_MATRIX_PRESENT`` > + - 0x00000080 > + - > + > +``V4L2_CID_MPEG_VIDEO_H264_SCALING_MATRIX (struct)`` > + Specifies the scaling matrix (as extracted from the bitstream) for > + the associated H264 slice data. The bitstream parameters are > + defined according to :ref:`h264`, section 7.4.2.1.1.1 "Scaling > + List Semantics".For further documentation, refer to the above > + specification, unless there is an explicit comment stating > + otherwise. > + > + .. note:: > + > + This compound control is not yet part of the public kernel API and > + it is expected to change. > + > +.. c:type:: v4l2_ctrl_h264_scaling_matrix > + > +.. cssclass:: longtable > + > +.. flat-table:: struct v4l2_ctrl_h264_scaling_matrix > + :header-rows: 0 > + :stub-columns: 0 > + :widths: 1 1 2 > + > + * - __u8 > + - ``scaling_list_4x4[6][16]`` > + - > + * - __u8 > + - ``scaling_list_8x8[6][64]`` > + - > + > +``V4L2_CID_MPEG_VIDEO_H264_SLICE_PARAMS (struct)`` > + Specifies the slice parameters (as extracted from the bitstream) > + for the associated H264 slice data. This includes the necessary > + parameters for configuring a stateless hardware decoding pipeline > + for H264. The bitstream parameters are defined according to > + :ref:`h264`, section 7.4.3 "Slice Header Semantics". For further > + documentation, refer to the above specification, unless there is > + an explicit comment stating otherwise. > + > + .. note:: > + > + This compound control is not yet part of the public kernel API > + and it is expected to change. > + > + This structure is expected to be passed as an array, with one > + entry for each slice included in the bitstream buffer. > + > +.. c:type:: v4l2_ctrl_h264_slice_params > + > +.. cssclass:: longtable > + > +.. flat-table:: struct v4l2_ctrl_h264_slice_params > + :header-rows: 0 > + :stub-columns: 0 > + :widths: 1 1 2 > + > + * - __u32 > + - ``size`` > + - > + * - __u32 > + - ``header_bit_size`` > + - > + * - __u16 > + - ``first_mb_in_slice`` > + - > + * - __u8 > + - ``slice_type`` > + - > + * - __u8 > + - ``pic_parameter_set_id`` > + - > + * - __u8 > + - ``colour_plane_id`` > + - > + * - __u8 > + - ``redundant_pic_cnt`` > + - > + * - __u16 > + - ``frame_num`` > + - > + * - __u16 > + - ``idr_pic_id`` > + - > + * - __u16 > + - ``pic_order_cnt_lsb`` > + - > + * - __s32 > + - ``delta_pic_order_cnt_bottom`` > + - > + * - __s32 > + - ``delta_pic_order_cnt0`` > + - > + * - __s32 > + - ``delta_pic_order_cnt1`` > + - > + * - struct :c:type:`v4l2_h264_pred_weight_table` > + - ``pred_weight_table`` > + - > + * - __u32 > + - ``dec_ref_pic_marking_bit_size`` > + - > + * - __u32 > + - ``pic_order_cnt_bit_size`` > + - > + * - __u8 > + - ``cabac_init_idc`` > + - > + * - __s8 > + - ``slice_qp_delta`` > + - > + * - __s8 > + - ``slice_qs_delta`` > + - > + * - __u8 > + - ``disable_deblocking_filter_idc`` > + - > + * - __s8 > + - ``slice_alpha_c0_offset_div2`` > + - > + * - __s8 > + - ``slice_beta_offset_div2`` > + - > + * - __u8 > + - ``num_ref_idx_l0_active_minus1`` > + - > + * - __u8 > + - ``num_ref_idx_l1_active_minus1`` > + - > + * - __u32 > + - ``slice_group_change_cycle`` > + - > + * - __u8 > + - ``ref_pic_list0[32]`` > + - Reference picture list after applying the per-slice modifications > + * - __u8 > + - ``ref_pic_list1[32]`` > + - Reference picture list after applying the per-slice modifications > + * - __u32 > + - ``flags`` > + - See :ref:`Slice Parameter Flags ` > + > +.. _h264_slice_flags: > + > +``Slice Parameter Set Flags`` > + > +.. cssclass:: longtable > + > +.. flat-table:: > + :header-rows: 0 > + :stub-columns: 0 > + :widths: 1 1 2 > + > + * - ``V4L2_H264_SLICE_FLAG_FIELD_PIC`` > + - 0x00000001 > + - > + * - ``V4L2_H264_SLICE_FLAG_BOTTOM_FIELD`` > + - 0x00000002 > + - > + * - ``V4L2_H264_SLICE_FLAG_DIRECT_SPATIAL_MV_PRED`` > + - 0x00000004 > + - > + * - ``V4L2_H264_SLICE_FLAG_SP_FOR_SWITCH`` > + - 0x00000008 > + - > + > +``Prediction Weight Table`` > + > + The bitstream parameters are defined according to :ref:`h264`, > + section 7.4.3.2 "Prediction Weight Table Semantics". For further > + documentation, refer to the above specification, unless there is > + an explicit comment stating otherwise. > + > +.. c:type:: v4l2_h264_pred_weight_table > + > +.. cssclass:: longtable > + > +.. flat-table:: struct v4l2_h264_pred_weight_table > + :header-rows: 0 > + :stub-columns: 0 > + :widths: 1 1 2 > + > + * - __u16 > + - ``luma_log2_weight_denom`` > + - > + * - __u16 > + - ``chroma_log2_weight_denom`` > + - > + * - struct :c:type:`v4l2_h264_weight_factors` > + - ``weight_factors[2]`` > + - The weight factors at index 0 are the weight factors for the reference > + list 0, the one at index 1 for the reference list 1. > + > +.. c:type:: v4l2_h264_weight_factors > + > +.. cssclass:: longtable > + > +.. flat-table:: struct v4l2_h264_weight_factors > + :header-rows: 0 > + :stub-columns: 0 > + :widths: 1 1 2 > + > + * - __s16 > + - ``luma_weight[32]`` > + - > + * - __s16 > + - ``luma_offset[32]`` > + - > + * - __s16 > + - ``chroma_weight[32][2]`` > + - > + * - __s16 > + - ``chroma_offset[32][2]`` > + - > + > +``V4L2_CID_MPEG_VIDEO_H264_DECODE_PARAMS (struct)`` > + Specifies the decode parameters (as extracted from the bitstream) > + for the associated H264 slice data. This includes the necessary > + parameters for configuring a stateless hardware decoding pipeline > + for H264. The bitstream parameters are defined according to > + :ref:`h264`. For further documentation, refer to the above > + specification, unless there is an explicit comment stating > + otherwise. > + > + .. note:: > + > + This compound control is not yet part of the public kernel API and > + it is expected to change. > + > +.. c:type:: v4l2_ctrl_h264_decode_params > + > +.. cssclass:: longtable > + > +.. flat-table:: struct v4l2_ctrl_h264_decode_params > + :header-rows: 0 > + :stub-columns: 0 > + :widths: 1 1 2 > + > + * - __u32 > + - ``num_slices`` > + - Number of slices needed to decode the current frame > + * - __u32 > + - ``nal_ref_idc`` > + - NAL reference ID value coming from the NAL Unit header > + * - __u8 > + - ``ref_pic_list_p0[32]`` > + - Backward reference list used by P-frames in the original bitstream order > + * - __u8 > + - ``ref_pic_list_b0[32]`` > + - Backward reference list used by B-frames in the original bitstream order > + * - __u8 > + - ``ref_pic_list_b1[32]`` > + - Forward reference list used by B-frames in the original bitstream order > + * - __s32 > + - ``top_field_order_cnt`` > + - Picture Order Count for the coded top field > + * - __s32 > + - ``bottom_field_order_cnt`` > + - Picture Order Count for the coded bottom field > + * - __u32 > + - ``flags`` > + - See :ref:`Decode Parameters Flags ` > + * - struct :c:type:`v4l2_h264_dpb_entry` > + - ``dpb[16]`` > + - > + > +.. _h264_decode_params_flags: > + > +``Decode Parameters Flags`` > + > +.. cssclass:: longtable > + > +.. flat-table:: > + :header-rows: 0 > + :stub-columns: 0 > + :widths: 1 1 2 > + > + * - ``V4L2_H264_DECODE_PARAM_FLAG_IDR_PIC`` > + - 0x00000001 > + - That picture is an IDR picture > + > +.. c:type:: v4l2_h264_dpb_entry > + > +.. cssclass:: longtable > + > +.. flat-table:: struct v4l2_h264_dpb_entry > + :header-rows: 0 > + :stub-columns: 0 > + :widths: 1 1 2 > + > + * - __u64 > + - ``reference_ts`` > + - Timestamp of the V4L2 capture buffer to use as reference, used > + with B-coded and P-coded frames. The timestamp refers to the > + ``timestamp`` field in struct :c:type:`v4l2_buffer`. Use the > + :c:func:`v4l2_timeval_to_ns()` function to convert the struct > + :c:type:`timeval` in struct :c:type:`v4l2_buffer` to a __u64. > + * - __u16 > + - ``frame_num`` > + - > + * - __u16 > + - ``pic_num`` > + - > + * - __s32 > + - ``top_field_order_cnt`` > + - > + * - __s32 > + - ``bottom_field_order_cnt`` > + - > + * - __u32 > + - ``flags`` > + - See :ref:`DPB Entry Flags ` > + > +.. _h264_dpb_flags: > + > +``DPB Entries Flags`` > + > +.. cssclass:: longtable > + > +.. flat-table:: > + :header-rows: 0 > + :stub-columns: 0 > + :widths: 1 1 2 > + > + * - ``V4L2_H264_DPB_ENTRY_FLAG_VALID`` > + - 0x00000001 > + - The DPB entry is valid and should be considered > + * - ``V4L2_H264_DPB_ENTRY_FLAG_ACTIVE`` > + - 0x00000002 > + - The DPB entry is currently being used as a reference frame > + * - ``V4L2_H264_DPB_ENTRY_FLAG_LONG_TERM`` > + - 0x00000004 > + - The DPB entry is a long term reference frame > > .. _v4l2-mpeg-mpeg2: > > diff --git a/Documentation/media/uapi/v4l/pixfmt-compressed.rst b/Documentation/media/uapi/v4l/pixfmt-compressed.rst > index 6c961cfb74da..ea0a8a68759b 100644 > --- a/Documentation/media/uapi/v4l/pixfmt-compressed.rst > +++ b/Documentation/media/uapi/v4l/pixfmt-compressed.rst > @@ -52,6 +52,25 @@ Compressed Formats > - ``V4L2_PIX_FMT_H264_MVC`` > - 'M264' > - H264 MVC video elementary stream. > + * .. _V4L2-PIX-FMT-H264-SLICE: > + > + - ``V4L2_PIX_FMT_H264_SLICE_RAW`` > + - 'S264' > + - H264 parsed slice data, as extracted from the H264 bitstream. > + This format is adapted for stateless video decoders that > + implement an H264 pipeline (using the :ref:`codec` and > + :ref:`media-request-api`). Metadata associated with the frame > + to decode are required to be passed through the > + ``V4L2_CID_MPEG_VIDEO_H264_SPS``, > + ``V4L2_CID_MPEG_VIDEO_H264_PPS``, > + ``V4L2_CID_MPEG_VIDEO_H264_SCALING_MATRIX``, > + ``V4L2_CID_MPEG_VIDEO_H264_SLICE_PARAMS`` and > + ``V4L2_CID_MPEG_VIDEO_H264_DECODE_PARAMS`` controls. See the > + :ref:`associated Codec Control IDs `. > + Exactly one output and one capture buffer must be provided for > + use with this pixel format. The output buffer must contain the > + appropriate number of macroblocks to decode a full > + corresponding frame to the matching capture buffer. > * .. _V4L2-PIX-FMT-H263: > > - ``V4L2_PIX_FMT_H263`` > diff --git a/Documentation/media/uapi/v4l/vidioc-queryctrl.rst b/Documentation/media/uapi/v4l/vidioc-queryctrl.rst > index f824162d0ea9..dc500632095d 100644 > --- a/Documentation/media/uapi/v4l/vidioc-queryctrl.rst > +++ b/Documentation/media/uapi/v4l/vidioc-queryctrl.rst > @@ -443,6 +443,36 @@ See also the examples in :ref:`control`. > - n/a > - A struct :c:type:`v4l2_ctrl_mpeg2_quantization`, containing MPEG-2 > quantization matrices for stateless video decoders. > + * - ``V4L2_CTRL_TYPE_H264_SPS`` > + - n/a > + - n/a > + - n/a > + - A struct :c:type:`v4l2_ctrl_h264_sps`, containing H264 > + sequence parameters for stateless video decoders. > + * - ``V4L2_CTRL_TYPE_H264_PPS`` > + - n/a > + - n/a > + - n/a > + - A struct :c:type:`v4l2_ctrl_h264_pps`, containing H264 > + picture parameters for stateless video decoders. > + * - ``V4L2_CTRL_TYPE_H264_SCALING_MATRIX`` > + - n/a > + - n/a > + - n/a > + - A struct :c:type:`v4l2_ctrl_h264_scaling_matrix`, containing H264 > + scaling matrices for stateless video decoders. > + * - ``V4L2_CTRL_TYPE_H264_SLICE_PARAMS`` > + - n/a > + - n/a > + - n/a > + - A struct :c:type:`v4l2_ctrl_h264_slice_params`, containing H264 > + slice parameters for stateless video decoders. > + * - ``V4L2_CTRL_TYPE_H264_DECODE_PARAMS`` > + - n/a > + - n/a > + - n/a > + - A struct :c:type:`v4l2_ctrl_h264_decode_params`, containing H264 > + decode parameters for stateless video decoders. > > .. tabularcolumns:: |p{6.6cm}|p{2.2cm}|p{8.7cm}| > > diff --git a/Documentation/media/videodev2.h.rst.exceptions b/Documentation/media/videodev2.h.rst.exceptions > index 64d348e67df9..55cbe324b9fc 100644 > --- a/Documentation/media/videodev2.h.rst.exceptions > +++ b/Documentation/media/videodev2.h.rst.exceptions > @@ -136,6 +136,11 @@ replace symbol V4L2_CTRL_TYPE_U32 :c:type:`v4l2_ctrl_type` > replace symbol V4L2_CTRL_TYPE_U8 :c:type:`v4l2_ctrl_type` > replace symbol V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS :c:type:`v4l2_ctrl_type` > replace symbol V4L2_CTRL_TYPE_MPEG2_QUANTIZATION :c:type:`v4l2_ctrl_type` > +replace symbol V4L2_CTRL_TYPE_H264_SPS :c:type:`v4l2_ctrl_type` > +replace symbol V4L2_CTRL_TYPE_H264_PPS :c:type:`v4l2_ctrl_type` > +replace symbol V4L2_CTRL_TYPE_H264_SCALING_MATRIX :c:type:`v4l2_ctrl_type` > +replace symbol V4L2_CTRL_TYPE_H264_SLICE_PARAMS :c:type:`v4l2_ctrl_type` > +replace symbol V4L2_CTRL_TYPE_H264_DECODE_PARAMS :c:type:`v4l2_ctrl_type` > > # V4L2 capability defines > replace define V4L2_CAP_VIDEO_CAPTURE device-capabilities > diff --git a/drivers/media/v4l2-core/v4l2-ctrls.c b/drivers/media/v4l2-core/v4l2-ctrls.c > index b1ae2e555c68..46aec8c3acde 100644 > --- a/drivers/media/v4l2-core/v4l2-ctrls.c > +++ b/drivers/media/v4l2-core/v4l2-ctrls.c > @@ -828,6 +828,11 @@ const char *v4l2_ctrl_get_name(u32 id) > case V4L2_CID_MPEG_VIDEO_H264_CONSTRAINED_INTRA_PREDICTION: > return "H264 Constrained Intra Pred"; > case V4L2_CID_MPEG_VIDEO_H264_CHROMA_QP_INDEX_OFFSET: return "H264 Chroma QP Index Offset"; > + case V4L2_CID_MPEG_VIDEO_H264_SPS: return "H264 Sequence Parameter Set"; > + case V4L2_CID_MPEG_VIDEO_H264_PPS: return "H264 Picture Parameter Set"; > + case V4L2_CID_MPEG_VIDEO_H264_SCALING_MATRIX: return "H264 Scaling Matrix"; > + case V4L2_CID_MPEG_VIDEO_H264_SLICE_PARAMS: return "H264 Slice Parameters"; > + case V4L2_CID_MPEG_VIDEO_H264_DECODE_PARAMS: return "H264 Decode Parameters"; > case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP: return "MPEG4 I-Frame QP Value"; > case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP: return "MPEG4 P-Frame QP Value"; > case V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP: return "MPEG4 B-Frame QP Value"; > @@ -1309,6 +1314,21 @@ void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type, > case V4L2_CID_MPEG_VIDEO_FWHT_PARAMS: > *type = V4L2_CTRL_TYPE_FWHT_PARAMS; > break; > + case V4L2_CID_MPEG_VIDEO_H264_SPS: > + *type = V4L2_CTRL_TYPE_H264_SPS; > + break; > + case V4L2_CID_MPEG_VIDEO_H264_PPS: > + *type = V4L2_CTRL_TYPE_H264_PPS; > + break; > + case V4L2_CID_MPEG_VIDEO_H264_SCALING_MATRIX: > + *type = V4L2_CTRL_TYPE_H264_SCALING_MATRIX; > + break; > + case V4L2_CID_MPEG_VIDEO_H264_SLICE_PARAMS: > + *type = V4L2_CTRL_TYPE_H264_SLICE_PARAMS; > + break; > + case V4L2_CID_MPEG_VIDEO_H264_DECODE_PARAMS: > + *type = V4L2_CTRL_TYPE_H264_DECODE_PARAMS; > + break; > default: > *type = V4L2_CTRL_TYPE_INTEGER; > break; > @@ -1678,6 +1698,13 @@ static int std_validate(const struct v4l2_ctrl *ctrl, u32 idx, > case V4L2_CTRL_TYPE_FWHT_PARAMS: > return 0; > > + case V4L2_CTRL_TYPE_H264_SPS: > + case V4L2_CTRL_TYPE_H264_PPS: > + case V4L2_CTRL_TYPE_H264_SCALING_MATRIX: > + case V4L2_CTRL_TYPE_H264_SLICE_PARAMS: > + case V4L2_CTRL_TYPE_H264_DECODE_PARAMS: > + return 0; > + > default: > return -EINVAL; > } > @@ -2261,6 +2288,21 @@ static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl, > case V4L2_CTRL_TYPE_FWHT_PARAMS: > elem_size = sizeof(struct v4l2_ctrl_fwht_params); > break; > + case V4L2_CTRL_TYPE_H264_SPS: > + elem_size = sizeof(struct v4l2_ctrl_h264_sps); > + break; > + case V4L2_CTRL_TYPE_H264_PPS: > + elem_size = sizeof(struct v4l2_ctrl_h264_pps); > + break; > + case V4L2_CTRL_TYPE_H264_SCALING_MATRIX: > + elem_size = sizeof(struct v4l2_ctrl_h264_scaling_matrix); > + break; > + case V4L2_CTRL_TYPE_H264_SLICE_PARAMS: > + elem_size = sizeof(struct v4l2_ctrl_h264_slice_params); > + break; > + case V4L2_CTRL_TYPE_H264_DECODE_PARAMS: > + elem_size = sizeof(struct v4l2_ctrl_h264_decode_params); > + break; > default: > if (type < V4L2_CTRL_COMPOUND_TYPES) > elem_size = sizeof(s32); > diff --git a/drivers/media/v4l2-core/v4l2-ioctl.c b/drivers/media/v4l2-core/v4l2-ioctl.c > index ac87c3e37280..f6e1254064d2 100644 > --- a/drivers/media/v4l2-core/v4l2-ioctl.c > +++ b/drivers/media/v4l2-core/v4l2-ioctl.c > @@ -1325,6 +1325,7 @@ static void v4l_fill_fmtdesc(struct v4l2_fmtdesc *fmt) > case V4L2_PIX_FMT_H264: descr = "H.264"; break; > case V4L2_PIX_FMT_H264_NO_SC: descr = "H.264 (No Start Codes)"; break; > case V4L2_PIX_FMT_H264_MVC: descr = "H.264 MVC"; break; > + case V4L2_PIX_FMT_H264_SLICE_RAW: descr = "H.264 Parsed Slice Data"; break; > case V4L2_PIX_FMT_H263: descr = "H.263"; break; > case V4L2_PIX_FMT_MPEG1: descr = "MPEG-1 ES"; break; > case V4L2_PIX_FMT_MPEG2: descr = "MPEG-2 ES"; break; > diff --git a/include/media/h264-ctrls.h b/include/media/h264-ctrls.h > new file mode 100644 > index 000000000000..e2f83b3cdbef > --- /dev/null > +++ b/include/media/h264-ctrls.h > @@ -0,0 +1,192 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > +/* > + * These are the H.264 state controls for use with stateless H.264 > + * codec drivers. > + * > + * It turns out that these structs are not stable yet and will undergo > + * more changes. So keep them private until they are stable and ready to > + * become part of the official public API. > + */ > + > +#ifndef _H264_CTRLS_H_ > +#define _H264_CTRLS_H_ > + > +/* > + * This is put insanely high to avoid conflicting with controls that > + * would be added during the phase where those controls are not > + * stable. It should be fixed eventually. > + */ > +#define V4L2_CID_MPEG_VIDEO_H264_SPS (V4L2_CID_MPEG_BASE+1000) > +#define V4L2_CID_MPEG_VIDEO_H264_PPS (V4L2_CID_MPEG_BASE+1001) > +#define V4L2_CID_MPEG_VIDEO_H264_SCALING_MATRIX (V4L2_CID_MPEG_BASE+1002) > +#define V4L2_CID_MPEG_VIDEO_H264_SLICE_PARAMS (V4L2_CID_MPEG_BASE+1003) > +#define V4L2_CID_MPEG_VIDEO_H264_DECODE_PARAMS (V4L2_CID_MPEG_BASE+1004) > + > +/* enum v4l2_ctrl_type type values */ > +#define V4L2_CTRL_TYPE_H264_SPS 0x0110 > +#define V4L2_CTRL_TYPE_H264_PPS 0x0111 > +#define V4L2_CTRL_TYPE_H264_SCALING_MATRIX 0x0112 > +#define V4L2_CTRL_TYPE_H264_SLICE_PARAMS 0x0113 > +#define V4L2_CTRL_TYPE_H264_DECODE_PARAMS 0x0114 > + > +#define V4L2_H264_SPS_CONSTRAINT_SET0_FLAG 0x01 > +#define V4L2_H264_SPS_CONSTRAINT_SET1_FLAG 0x02 > +#define V4L2_H264_SPS_CONSTRAINT_SET2_FLAG 0x04 > +#define V4L2_H264_SPS_CONSTRAINT_SET3_FLAG 0x08 > +#define V4L2_H264_SPS_CONSTRAINT_SET4_FLAG 0x10 > +#define V4L2_H264_SPS_CONSTRAINT_SET5_FLAG 0x20 > + > +#define V4L2_H264_SPS_FLAG_SEPARATE_COLOUR_PLANE 0x01 > +#define V4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASS 0x02 > +#define V4L2_H264_SPS_FLAG_DELTA_PIC_ORDER_ALWAYS_ZERO 0x04 > +#define V4L2_H264_SPS_FLAG_GAPS_IN_FRAME_NUM_VALUE_ALLOWED 0x08 > +#define V4L2_H264_SPS_FLAG_FRAME_MBS_ONLY 0x10 > +#define V4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELD 0x20 > +#define V4L2_H264_SPS_FLAG_DIRECT_8X8_INFERENCE 0x40 > + > +struct v4l2_ctrl_h264_sps { > + __u8 profile_idc; > + __u8 constraint_set_flags; > + __u8 level_idc; > + __u8 seq_parameter_set_id; > + __u8 chroma_format_idc; > + __u8 bit_depth_luma_minus8; > + __u8 bit_depth_chroma_minus8; > + __u8 log2_max_frame_num_minus4; > + __u8 pic_order_cnt_type; > + __u8 log2_max_pic_order_cnt_lsb_minus4; > + __u8 max_num_ref_frames; > + __u8 num_ref_frames_in_pic_order_cnt_cycle; > + __s32 offset_for_ref_frame[255]; > + __s32 offset_for_non_ref_pic; > + __s32 offset_for_top_to_bottom_field; > + __u16 pic_width_in_mbs_minus1; > + __u16 pic_height_in_map_units_minus1; > + __u32 flags; > +}; > + > +#define V4L2_H264_PPS_FLAG_ENTROPY_CODING_MODE 0x0001 > +#define V4L2_H264_PPS_FLAG_BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENT 0x0002 > +#define V4L2_H264_PPS_FLAG_WEIGHTED_PRED 0x0004 > +#define V4L2_H264_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT 0x0008 > +#define V4L2_H264_PPS_FLAG_CONSTRAINED_INTRA_PRED 0x0010 > +#define V4L2_H264_PPS_FLAG_REDUNDANT_PIC_CNT_PRESENT 0x0020 > +#define V4L2_H264_PPS_FLAG_TRANSFORM_8X8_MODE 0x0040 > +#define V4L2_H264_PPS_FLAG_PIC_SCALING_MATRIX_PRESENT 0x0080 > + > +struct v4l2_ctrl_h264_pps { > + __u8 pic_parameter_set_id; > + __u8 seq_parameter_set_id; > + __u8 num_slice_groups_minus1; > + __u8 num_ref_idx_l0_default_active_minus1; > + __u8 num_ref_idx_l1_default_active_minus1; > + __u8 weighted_bipred_idc; > + __s8 pic_init_qp_minus26; > + __s8 pic_init_qs_minus26; > + __s8 chroma_qp_index_offset; > + __s8 second_chroma_qp_index_offset; > + __u16 flags; > +}; > + > +struct v4l2_ctrl_h264_scaling_matrix { > + __u8 scaling_list_4x4[6][16]; > + __u8 scaling_list_8x8[6][64]; > +}; > + > +struct v4l2_h264_weight_factors { > + __s16 luma_weight[32]; > + __s16 luma_offset[32]; > + __s16 chroma_weight[32][2]; > + __s16 chroma_offset[32][2]; > +}; > + > +struct v4l2_h264_pred_weight_table { > + __u16 luma_log2_weight_denom; > + __u16 chroma_log2_weight_denom; > + struct v4l2_h264_weight_factors weight_factors[2]; > +}; > + > +#define V4L2_H264_SLICE_TYPE_P 0 > +#define V4L2_H264_SLICE_TYPE_B 1 > +#define V4L2_H264_SLICE_TYPE_I 2 > +#define V4L2_H264_SLICE_TYPE_SP 3 > +#define V4L2_H264_SLICE_TYPE_SI 4 > + > +#define V4L2_H264_SLICE_FLAG_FIELD_PIC 0x01 > +#define V4L2_H264_SLICE_FLAG_BOTTOM_FIELD 0x02 > +#define V4L2_H264_SLICE_FLAG_DIRECT_SPATIAL_MV_PRED 0x04 > +#define V4L2_H264_SLICE_FLAG_SP_FOR_SWITCH 0x08 > + > +struct v4l2_ctrl_h264_slice_params { > + /* Size in bytes, including header */ > + __u32 size; > + /* Offset in bits to slice_data() from the beginning of this slice. */ > + __u32 header_bit_size; > + > + __u16 first_mb_in_slice; > + __u8 slice_type; > + __u8 pic_parameter_set_id; > + __u8 colour_plane_id; > + __u8 redundant_pic_cnt; > + __u16 frame_num; > + __u16 idr_pic_id; > + __u16 pic_order_cnt_lsb; > + __s32 delta_pic_order_cnt_bottom; > + __s32 delta_pic_order_cnt0; > + __s32 delta_pic_order_cnt1; > + > + struct v4l2_h264_pred_weight_table pred_weight_table; > + /* Size in bits of dec_ref_pic_marking() syntax element. */ > + __u32 dec_ref_pic_marking_bit_size; > + /* Size in bits of pic order count syntax. */ > + __u32 pic_order_cnt_bit_size; > + > + __u8 cabac_init_idc; > + __s8 slice_qp_delta; > + __s8 slice_qs_delta; > + __u8 disable_deblocking_filter_idc; > + __s8 slice_alpha_c0_offset_div2; > + __s8 slice_beta_offset_div2; > + __u8 num_ref_idx_l0_active_minus1; > + __u8 num_ref_idx_l1_active_minus1; > + __u32 slice_group_change_cycle; > + > + /* > + * Entries on each list are indices into > + * v4l2_ctrl_h264_decode_params.dpb[]. > + */ > + __u8 ref_pic_list0[32]; > + __u8 ref_pic_list1[32]; > + > + __u32 flags; > +}; > + > +#define V4L2_H264_DPB_ENTRY_FLAG_VALID 0x01 > +#define V4L2_H264_DPB_ENTRY_FLAG_ACTIVE 0x02 > +#define V4L2_H264_DPB_ENTRY_FLAG_LONG_TERM 0x04 > + > +struct v4l2_h264_dpb_entry { > + __u64 reference_ts; > + __u16 frame_num; > + __u16 pic_num; > + /* Note that field is indicated by v4l2_buffer.field */ > + __s32 top_field_order_cnt; > + __s32 bottom_field_order_cnt; > + __u32 flags; /* V4L2_H264_DPB_ENTRY_FLAG_* */ > +}; > + > +#define V4L2_H264_DECODE_PARAM_FLAG_IDR_PIC 0x01 > + > +struct v4l2_ctrl_h264_decode_params { > + struct v4l2_h264_dpb_entry dpb[16]; > + __u16 num_slices; > + __u16 nal_ref_idc; > + __u8 ref_pic_list_p0[32]; > + __u8 ref_pic_list_b0[32]; > + __u8 ref_pic_list_b1[32]; > + __s32 top_field_order_cnt; > + __s32 bottom_field_order_cnt; > + __u32 flags; /* V4L2_H264_DECODE_PARAM_FLAG_* */ > +}; > + > +#endif > diff --git a/include/media/v4l2-ctrls.h b/include/media/v4l2-ctrls.h > index bd621cec65a5..dce6f33fd749 100644 > --- a/include/media/v4l2-ctrls.h > +++ b/include/media/v4l2-ctrls.h > @@ -23,11 +23,12 @@ > #include > > /* > - * Include the mpeg2 and fwht stateless codec compound control definitions. > + * Include the stateless codec compound control definitions. > * This will move to the public headers once this API is fully stable. > */ > #include > #include > +#include > > /* forward references */ > struct file; > @@ -51,6 +52,11 @@ struct poll_table_struct; > * @p_mpeg2_slice_params: Pointer to a MPEG2 slice parameters structure. > * @p_mpeg2_quantization: Pointer to a MPEG2 quantization data structure. > * @p_fwht_params: Pointer to a FWHT stateless parameters structure. > + * @p_h264_sps: Pointer to a struct v4l2_ctrl_h264_sps. > + * @p_h264_pps: Pointer to a struct v4l2_ctrl_h264_pps. > + * @p_h264_scaling_matrix: Pointer to a struct v4l2_ctrl_h264_scaling_matrix. > + * @p_h264_slice_param: Pointer to a struct v4l2_ctrl_h264_slice_params. > + * @p_h264_decode_param: Pointer to a struct v4l2_ctrl_h264_decode_params. > * @p: Pointer to a compound value. > */ > union v4l2_ctrl_ptr { > @@ -63,6 +69,11 @@ union v4l2_ctrl_ptr { > struct v4l2_ctrl_mpeg2_slice_params *p_mpeg2_slice_params; > struct v4l2_ctrl_mpeg2_quantization *p_mpeg2_quantization; > struct v4l2_ctrl_fwht_params *p_fwht_params; > + struct v4l2_ctrl_h264_sps *p_h264_sps; > + struct v4l2_ctrl_h264_pps *p_h264_pps; > + struct v4l2_ctrl_h264_scaling_matrix *p_h264_scaling_matrix; > + struct v4l2_ctrl_h264_slice_params *p_h264_slice_param; > + struct v4l2_ctrl_h264_decode_params *p_h264_decode_param; > void *p; > }; > > diff --git a/include/uapi/linux/videodev2.h b/include/uapi/linux/videodev2.h > index 496e6453450c..838732acdefc 100644 > --- a/include/uapi/linux/videodev2.h > +++ b/include/uapi/linux/videodev2.h > @@ -657,6 +657,7 @@ struct v4l2_pix_format { > #define V4L2_PIX_FMT_H264 v4l2_fourcc('H', '2', '6', '4') /* H264 with start codes */ > #define V4L2_PIX_FMT_H264_NO_SC v4l2_fourcc('A', 'V', 'C', '1') /* H264 without start codes */ > #define V4L2_PIX_FMT_H264_MVC v4l2_fourcc('M', '2', '6', '4') /* H264 MVC */ > +#define V4L2_PIX_FMT_H264_SLICE_RAW v4l2_fourcc('S', '2', '6', '4') /* H264 parsed slices */ > #define V4L2_PIX_FMT_H263 v4l2_fourcc('H', '2', '6', '3') /* H263 */ > #define V4L2_PIX_FMT_MPEG1 v4l2_fourcc('M', 'P', 'G', '1') /* MPEG-1 ES */ > #define V4L2_PIX_FMT_MPEG2 v4l2_fourcc('M', 'P', 'G', '2') /* MPEG-2 ES */ -- Paul Kocialkowski, Bootlin Embedded Linux and kernel engineering https://bootlin.com From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.0 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3F09AC10F11 for ; Wed, 10 Apr 2019 13:45:08 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id D69CC20830 for ; Wed, 10 Apr 2019 13:45:07 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="BxrdUJzO" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D69CC20830 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=bootlin.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Date:To:From:Subject:Message-ID:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=Lm3CfNAs28yTbkZRCFChVQPbGdtHha5bnQuF9O3ZacQ=; b=BxrdUJzOe9OMa6 FRWojPByqqVf+VBAmLwnHyUKzfoe2SevO9aQs51BLbdTDcTxKWnZUwSFzNFkdLoe3nuQR1kgFniWs tm6SLwDkfC0fBnR6m+oRvXgntuFKt+iCVA6Izd2XKUT2yN0/oIsdhk7tizvOrpCx4D0Z5tS1KFTgi 9pMFelZk/oAz2IqphiqiFMsqiSd4OM6cauQrUrtM5mgo30jhgZBcJcWTQ6WyMaqrLkCsKNAixZ1jG NEi/nIiyCj11QatkKEhD5C44Cqs6I70tdsc25HYIbTtv4lF/q2UGVoSBe89myn+hvm7U/9FCz2ziy xoY2/FtzmEb6KIHxnagw==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1hEDX8-0001FD-Fu; Wed, 10 Apr 2019 13:44:58 +0000 Received: from relay3-d.mail.gandi.net ([217.70.183.195]) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1hEDWv-00012b-CO for linux-arm-kernel@lists.infradead.org; Wed, 10 Apr 2019 13:44:48 +0000 X-Originating-IP: 90.88.18.121 Received: from aptenodytes (aaubervilliers-681-1-63-121.w90-88.abo.wanadoo.fr [90.88.18.121]) (Authenticated sender: paul.kocialkowski@bootlin.com) by relay3-d.mail.gandi.net (Postfix) with ESMTPSA id B2FE260010; Wed, 10 Apr 2019 13:44:28 +0000 (UTC) Message-ID: Subject: Re: [PATCH v8 1/2] media: uapi: Add H264 low-level decoder API compound controls. From: Paul Kocialkowski To: Maxime Ripard , hans.verkuil@cisco.com, acourbot@chromium.org, sakari.ailus@linux.intel.com, Laurent Pinchart Date: Wed, 10 Apr 2019 15:44:28 +0200 In-Reply-To: References: Organization: Bootlin User-Agent: Evolution 3.32.0 MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190410_064445_733527_9FC68EDB X-CRM114-Status: GOOD ( 18.33 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: jonas@kwiboo.se, jenskuske@gmail.com, linux-sunxi@googlegroups.com, linux-kernel@vger.kernel.org, jernej.skrabec@gmail.com, tfiga@chromium.org, Chen-Yu Tsai , posciak@chromium.org, Thomas Petazzoni , Guenter Roeck , nicolas.dufresne@collabora.com, ezequiel@collabora.com, linux-arm-kernel@lists.infradead.org, linux-media@vger.kernel.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org SGksCgpMZSBqZXVkaSAwNCBhdnJpbCAyMDE5IMOgIDE0OjU5ICswMjAwLCBNYXhpbWUgUmlwYXJk IGEgw6ljcml0IDoKPiBGcm9tOiBQYXdlbCBPc2NpYWsgPHBvc2NpYWtAY2hyb21pdW0ub3JnPgo+ IAo+IFN0YXRlbGVzcyB2aWRlbyBjb2RlY3Mgd2lsbCByZXF1aXJlIGJvdGggdGhlIEgyNjQgbWV0 YWRhdGEgYW5kIHNsaWNlcyBpbgo+IG9yZGVyIHRvIGJlIGFibGUgdG8gZGVjb2RlIGZyYW1lcy4K PiAKPiBUaGlzIGludHJvZHVjZXMgdGhlIGRlZmluaXRpb25zIGZvciBhIG5ldyBwaXhlbCBmb3Jt YXQgZm9yIEgyNjQgc2xpY2VzIHRoYXQKPiBoYXZlIGJlZW4gcGFyc2VkLCBhcyB3ZWxsIGFzIHRo ZSBzdHJ1Y3R1cmVzIHVzZWQgdG8gcGFzcyB0aGUgbWV0YWRhdGEgZnJvbQo+IHRoZSB1c2Vyc3Bh Y2UgdG8gdGhlIGtlcm5lbC4KCldpdGggVjRMMl9QSVhfRk1UX0gyNjRfU0xJQ0VfUkFXIHJlbmFt ZWQgdG8gVjRMMl9QSVhfRk1UX0gyNjRfU0xJQ0UgYW5kCm1vdmVkIHRvIHRoZSBwcml2YXRlIGgy NjQtY3RybHMuaCwgdGhpcyBpczoKClJldmlld2VkLWJ5OiBQYXVsIEtvY2lhbGtvd3NraSA8cGF1 bC5rb2NpYWxrb3dza2lAYm9vdGxpbi5jb20+CgpDaGVlcnMsCgpQYXVsCgo+IFJldmlld2VkLWJ5 OiBUb21hc3ogRmlnYSA8dGZpZ2FAY2hyb21pdW0ub3JnPgo+IFNpZ25lZC1vZmYtYnk6IFBhd2Vs IE9zY2lhayA8cG9zY2lha0BjaHJvbWl1bS5vcmc+Cj4gU2lnbmVkLW9mZi1ieTogR3VlbnRlciBS b2VjayA8Z3JvZWNrQGNocm9taXVtLm9yZz4KPiBDby1kZXZlbG9wZWQtYnk6IE1heGltZSBSaXBh cmQgPG1heGltZS5yaXBhcmRAYm9vdGxpbi5jb20+Cj4gU2lnbmVkLW9mZi1ieTogTWF4aW1lIFJp cGFyZCA8bWF4aW1lLnJpcGFyZEBib290bGluLmNvbT4KPiAtLS0KPiAgRG9jdW1lbnRhdGlvbi9t ZWRpYS91YXBpL3Y0bC9iaWJsaW8ucnN0ICAgICAgICAgICAgfCAgIDkgKy0KPiAgRG9jdW1lbnRh dGlvbi9tZWRpYS91YXBpL3Y0bC9leHQtY3RybHMtY29kZWMucnN0ICAgfCA1NjkgKysrKysrKysr KysrKystCj4gIERvY3VtZW50YXRpb24vbWVkaWEvdWFwaS92NGwvcGl4Zm10LWNvbXByZXNzZWQu cnN0IHwgIDE5ICstCj4gIERvY3VtZW50YXRpb24vbWVkaWEvdWFwaS92NGwvdmlkaW9jLXF1ZXJ5 Y3RybC5yc3QgIHwgIDMwICstCj4gIERvY3VtZW50YXRpb24vbWVkaWEvdmlkZW9kZXYyLmgucnN0 LmV4Y2VwdGlvbnMgICAgIHwgICA1ICstCj4gIGRyaXZlcnMvbWVkaWEvdjRsMi1jb3JlL3Y0bDIt Y3RybHMuYyAgICAgICAgICAgICAgIHwgIDQyICstCj4gIGRyaXZlcnMvbWVkaWEvdjRsMi1jb3Jl L3Y0bDItaW9jdGwuYyAgICAgICAgICAgICAgIHwgICAxICstCj4gIGluY2x1ZGUvbWVkaWEvaDI2 NC1jdHJscy5oICAgICAgICAgICAgICAgICAgICAgICAgIHwgMTkyICsrKysrLQo+ICBpbmNsdWRl L21lZGlhL3Y0bDItY3RybHMuaCAgICAgICAgICAgICAgICAgICAgICAgICB8ICAxMyArLQo+ICBp bmNsdWRlL3VhcGkvbGludXgvdmlkZW9kZXYyLmggICAgICAgICAgICAgICAgICAgICB8ICAgMSAr LQo+ICAxMCBmaWxlcyBjaGFuZ2VkLCA4ODAgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQo+ ICBjcmVhdGUgbW9kZSAxMDA2NDQgaW5jbHVkZS9tZWRpYS9oMjY0LWN0cmxzLmgKPiAKPiBkaWZm IC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9tZWRpYS91YXBpL3Y0bC9iaWJsaW8ucnN0IGIvRG9jdW1l bnRhdGlvbi9tZWRpYS91YXBpL3Y0bC9iaWJsaW8ucnN0Cj4gaW5kZXggZWMzMzc2OGMwNTVlLi44 ZjRlYjg4MjNkODIgMTAwNjQ0Cj4gLS0tIGEvRG9jdW1lbnRhdGlvbi9tZWRpYS91YXBpL3Y0bC9i aWJsaW8ucnN0Cj4gKysrIGIvRG9jdW1lbnRhdGlvbi9tZWRpYS91YXBpL3Y0bC9iaWJsaW8ucnN0 Cj4gQEAgLTEyMiw2ICsxMjIsMTUgQEAgSVRVIEJULjExMTkKPiAgCj4gIDphdXRob3I6ICAgIElu dGVybmF0aW9uYWwgVGVsZWNvbW11bmljYXRpb24gVW5pb24gKGh0dHA6Ly93d3cuaXR1LmNoKQo+ ICAKPiArLi4gX2gyNjQ6Cj4gKwo+ICtJVFUtVCBSZWMuIEguMjY0IFNwZWNpZmljYXRpb24gKDA0 LzIwMTcgRWRpdGlvbikKPiArPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Cj4gKwo+ICs6dGl0bGU6ICAgICBJVFUtVCBSZWNvbW1lbmRhdGlvbiBILjI2NCAi QWR2YW5jZWQgVmlkZW8gQ29kaW5nIGZvciBHZW5lcmljIEF1ZGlvdmlzdWFsIFNlcnZpY2VzIgo+ ICsKPiArOmF1dGhvcjogICAgSW50ZXJuYXRpb25hbCBUZWxlY29tbXVuaWNhdGlvbiBVbmlvbiAo aHR0cDovL3d3dy5pdHUuY2gpCj4gKwo+ICAuLiBfamZpZjoKPiAgCj4gIEpGSUYKPiBkaWZmIC0t Z2l0IGEvRG9jdW1lbnRhdGlvbi9tZWRpYS91YXBpL3Y0bC9leHQtY3RybHMtY29kZWMucnN0IGIv RG9jdW1lbnRhdGlvbi9tZWRpYS91YXBpL3Y0bC9leHQtY3RybHMtY29kZWMucnN0Cj4gaW5kZXgg NjdhMTIyMzM5YzBlLi5mZTcyMGYyMzlmNzAgMTAwNjQ0Cj4gLS0tIGEvRG9jdW1lbnRhdGlvbi9t ZWRpYS91YXBpL3Y0bC9leHQtY3RybHMtY29kZWMucnN0Cj4gKysrIGIvRG9jdW1lbnRhdGlvbi9t ZWRpYS91YXBpL3Y0bC9leHQtY3RybHMtY29kZWMucnN0Cj4gQEAgLTEzNzEsNiArMTM3MSw1NzUg QEAgZW51bSB2NGwyX21wZWdfdmlkZW9faDI2NF9oaWVyYXJjaGljYWxfY29kaW5nX3R5cGUgLQo+ ICAgICAgICAtIExheWVyIG51bWJlcgo+ICAKPiAgCj4gKy4uIF92NGwyLW1wZWctaDI2NDoKPiAr Cj4gK2BgVjRMMl9DSURfTVBFR19WSURFT19IMjY0X1NQUyAoc3RydWN0KWBgCj4gKyAgICBTcGVj aWZpZXMgdGhlIHNlcXVlbmNlIHBhcmFtZXRlciBzZXQgKGFzIGV4dHJhY3RlZCBmcm9tIHRoZQo+ ICsgICAgYml0c3RyZWFtKSBmb3IgdGhlIGFzc29jaWF0ZWQgSDI2NCBzbGljZSBkYXRhLiBUaGlz IGluY2x1ZGVzIHRoZQo+ICsgICAgbmVjZXNzYXJ5IHBhcmFtZXRlcnMgZm9yIGNvbmZpZ3VyaW5n IGEgc3RhdGVsZXNzIGhhcmR3YXJlIGRlY29kaW5nCj4gKyAgICBwaXBlbGluZSBmb3IgSDI2NC4g VGhlIGJpdHN0cmVhbSBwYXJhbWV0ZXJzIGFyZSBkZWZpbmVkIGFjY29yZGluZwo+ICsgICAgdG8g OnJlZjpgaDI2NGAsIHNlY3Rpb24gNy40LjIuMS4xICJTZXF1ZW5jZSBQYXJhbWV0ZXIgU2V0IERh dGEKPiArICAgIFNlbWFudGljcyIuIEZvciBmdXJ0aGVyIGRvY3VtZW50YXRpb24sIHJlZmVyIHRv IHRoZSBhYm92ZQo+ICsgICAgc3BlY2lmaWNhdGlvbiwgdW5sZXNzIHRoZXJlIGlzIGFuIGV4cGxp Y2l0IGNvbW1lbnQgc3RhdGluZwo+ICsgICAgb3RoZXJ3aXNlLgo+ICsKPiArICAgIC4uIG5vdGU6 Ogo+ICsKPiArICAgICAgIFRoaXMgY29tcG91bmQgY29udHJvbCBpcyBub3QgeWV0IHBhcnQgb2Yg dGhlIHB1YmxpYyBrZXJuZWwgQVBJIGFuZAo+ICsgICAgICAgaXQgaXMgZXhwZWN0ZWQgdG8gY2hh bmdlLgo+ICsKPiArLi4gYzp0eXBlOjogdjRsMl9jdHJsX2gyNjRfc3BzCj4gKwo+ICsuLiBjc3Nj bGFzczo6IGxvbmd0YWJsZQo+ICsKPiArLi4gZmxhdC10YWJsZTo6IHN0cnVjdCB2NGwyX2N0cmxf aDI2NF9zcHMKPiArICAgIDpoZWFkZXItcm93czogIDAKPiArICAgIDpzdHViLWNvbHVtbnM6IDAK PiArICAgIDp3aWR0aHM6ICAgICAgIDEgMSAyCj4gKwo+ICsgICAgKiAtIF9fdTgKPiArICAgICAg LSBgYHByb2ZpbGVfaWRjYGAKPiArICAgICAgLQo+ICsgICAgKiAtIF9fdTgKPiArICAgICAgLSBg YGNvbnN0cmFpbnRfc2V0X2ZsYWdzYGAKPiArICAgICAgLSBTZWUgOnJlZjpgU2VxdWVuY2UgUGFy YW1ldGVyIFNldCBDb25zdHJhaW50cyBTZXQgRmxhZ3MgPGgyNjRfc3BzX2NvbnN0cmFpbnRzX3Nl dF9mbGFncz5gCj4gKyAgICAqIC0gX191OAo+ICsgICAgICAtIGBgbGV2ZWxfaWRjYGAKPiArICAg ICAgLQo+ICsgICAgKiAtIF9fdTgKPiArICAgICAgLSBgYHNlcV9wYXJhbWV0ZXJfc2V0X2lkYGAK PiArICAgICAgLQo+ICsgICAgKiAtIF9fdTgKPiArICAgICAgLSBgYGNocm9tYV9mb3JtYXRfaWRj YGAKPiArICAgICAgLQo+ICsgICAgKiAtIF9fdTgKPiArICAgICAgLSBgYGJpdF9kZXB0aF9sdW1h X21pbnVzOGBgCj4gKyAgICAgIC0KPiArICAgICogLSBfX3U4Cj4gKyAgICAgIC0gYGBiaXRfZGVw dGhfY2hyb21hX21pbnVzOGBgCj4gKyAgICAgIC0KPiArICAgICogLSBfX3U4Cj4gKyAgICAgIC0g YGBsb2cyX21heF9mcmFtZV9udW1fbWludXM0YGAKPiArICAgICAgLQo+ICsgICAgKiAtIF9fdTgK PiArICAgICAgLSBgYHBpY19vcmRlcl9jbnRfdHlwZWBgCj4gKyAgICAgIC0KPiArICAgICogLSBf X3U4Cj4gKyAgICAgIC0gYGBsb2cyX21heF9waWNfb3JkZXJfY250X2xzYl9taW51czRgYAo+ICsg ICAgICAtCj4gKyAgICAqIC0gX191OAo+ICsgICAgICAtIGBgbWF4X251bV9yZWZfZnJhbWVzYGAK PiArICAgICAgLQo+ICsgICAgKiAtIF9fdTgKPiArICAgICAgLSBgYG51bV9yZWZfZnJhbWVzX2lu X3BpY19vcmRlcl9jbnRfY3ljbGVgYAo+ICsgICAgICAtCj4gKyAgICAqIC0gX19zMzIKPiArICAg ICAgLSBgYG9mZnNldF9mb3JfcmVmX2ZyYW1lWzI1NV1gYAo+ICsgICAgICAtCj4gKyAgICAqIC0g X19zMzIKPiArICAgICAgLSBgYG9mZnNldF9mb3Jfbm9uX3JlZl9waWNgYAo+ICsgICAgICAtCj4g KyAgICAqIC0gX19zMzIKPiArICAgICAgLSBgYG9mZnNldF9mb3JfdG9wX3RvX2JvdHRvbV9maWVs ZGBgCj4gKyAgICAgIC0KPiArICAgICogLSBfX3UxNgo+ICsgICAgICAtIGBgcGljX3dpZHRoX2lu X21ic19taW51czFgYAo+ICsgICAgICAtCj4gKyAgICAqIC0gX191MTYKPiArICAgICAgLSBgYHBp Y19oZWlnaHRfaW5fbWFwX3VuaXRzX21pbnVzMWBgCj4gKyAgICAgIC0KPiArICAgICogLSBfX3Uz Mgo+ICsgICAgICAtIGBgZmxhZ3NgYAo+ICsgICAgICAtIFNlZSA6cmVmOmBTZXF1ZW5jZSBQYXJh bWV0ZXIgU2V0IEZsYWdzIDxoMjY0X3Nwc19mbGFncz5gCj4gKwo+ICsuLiBfaDI2NF9zcHNfY29u c3RyYWludHNfc2V0X2ZsYWdzOgo+ICsKPiArYGBTZXF1ZW5jZSBQYXJhbWV0ZXIgU2V0IENvbnN0 cmFpbnRzIFNldCBGbGFnc2BgCj4gKwo+ICsuLiBjc3NjbGFzczo6IGxvbmd0YWJsZQo+ICsKPiAr Li4gZmxhdC10YWJsZTo6Cj4gKyAgICA6aGVhZGVyLXJvd3M6ICAwCj4gKyAgICA6c3R1Yi1jb2x1 bW5zOiAwCj4gKyAgICA6d2lkdGhzOiAgICAgICAxIDEgMgo+ICsKPiArICAgICogLSBgYFY0TDJf SDI2NF9TUFNfQ09OU1RSQUlOVF9TRVQwX0ZMQUdgYAo+ICsgICAgICAtIDB4MDAwMDAwMDEKPiAr ICAgICAgLQo+ICsgICAgKiAtIGBgVjRMMl9IMjY0X1NQU19DT05TVFJBSU5UX1NFVDFfRkxBR2Bg Cj4gKyAgICAgIC0gMHgwMDAwMDAwMgo+ICsgICAgICAtCj4gKyAgICAqIC0gYGBWNEwyX0gyNjRf U1BTX0NPTlNUUkFJTlRfU0VUMl9GTEFHYGAKPiArICAgICAgLSAweDAwMDAwMDA0Cj4gKyAgICAg IC0KPiArICAgICogLSBgYFY0TDJfSDI2NF9TUFNfQ09OU1RSQUlOVF9TRVQzX0ZMQUdgYAo+ICsg ICAgICAtIDB4MDAwMDAwMDgKPiArICAgICAgLQo+ICsgICAgKiAtIGBgVjRMMl9IMjY0X1NQU19D T05TVFJBSU5UX1NFVDRfRkxBR2BgCj4gKyAgICAgIC0gMHgwMDAwMDAxMAo+ICsgICAgICAtCj4g KyAgICAqIC0gYGBWNEwyX0gyNjRfU1BTX0NPTlNUUkFJTlRfU0VUNV9GTEFHYGAKPiArICAgICAg LSAweDAwMDAwMDIwCj4gKyAgICAgIC0KPiArCj4gKy4uIF9oMjY0X3Nwc19mbGFnczoKPiArCj4g K2BgU2VxdWVuY2UgUGFyYW1ldGVyIFNldCBGbGFnc2BgCj4gKwo+ICsuLiBjc3NjbGFzczo6IGxv bmd0YWJsZQo+ICsKPiArLi4gZmxhdC10YWJsZTo6Cj4gKyAgICA6aGVhZGVyLXJvd3M6ICAwCj4g KyAgICA6c3R1Yi1jb2x1bW5zOiAwCj4gKyAgICA6d2lkdGhzOiAgICAgICAxIDEgMgo+ICsKPiAr ICAgICogLSBgYFY0TDJfSDI2NF9TUFNfRkxBR19TRVBBUkFURV9DT0xPVVJfUExBTkVgYAo+ICsg ICAgICAtIDB4MDAwMDAwMDEKPiArICAgICAgLQo+ICsgICAgKiAtIGBgVjRMMl9IMjY0X1NQU19G TEFHX1FQUFJJTUVfWV9aRVJPX1RSQU5TRk9STV9CWVBBU1NgYAo+ICsgICAgICAtIDB4MDAwMDAw MDIKPiArICAgICAgLQo+ICsgICAgKiAtIGBgVjRMMl9IMjY0X1NQU19GTEFHX0RFTFRBX1BJQ19P UkRFUl9BTFdBWVNfWkVST2BgCj4gKyAgICAgIC0gMHgwMDAwMDAwNAo+ICsgICAgICAtCj4gKyAg ICAqIC0gYGBWNEwyX0gyNjRfU1BTX0ZMQUdfR0FQU19JTl9GUkFNRV9OVU1fVkFMVUVfQUxMT1dF RGBgCj4gKyAgICAgIC0gMHgwMDAwMDAwOAo+ICsgICAgICAtCj4gKyAgICAqIC0gYGBWNEwyX0gy NjRfU1BTX0ZMQUdfRlJBTUVfTUJTX09OTFlgYAo+ICsgICAgICAtIDB4MDAwMDAwMTAKPiArICAg ICAgLQo+ICsgICAgKiAtIGBgVjRMMl9IMjY0X1NQU19GTEFHX01CX0FEQVBUSVZFX0ZSQU1FX0ZJ RUxEYGAKPiArICAgICAgLSAweDAwMDAwMDIwCj4gKyAgICAgIC0KPiArICAgICogLSBgYFY0TDJf SDI2NF9TUFNfRkxBR19ESVJFQ1RfOFg4X0lORkVSRU5DRWBgCj4gKyAgICAgIC0gMHgwMDAwMDA0 MAo+ICsgICAgICAtCj4gKwo+ICtgYFY0TDJfQ0lEX01QRUdfVklERU9fSDI2NF9QUFMgKHN0cnVj dClgYAo+ICsgICAgU3BlY2lmaWVzIHRoZSBwaWN0dXJlIHBhcmFtZXRlciBzZXQgKGFzIGV4dHJh Y3RlZCBmcm9tIHRoZQo+ICsgICAgYml0c3RyZWFtKSBmb3IgdGhlIGFzc29jaWF0ZWQgSDI2NCBz bGljZSBkYXRhLiBUaGlzIGluY2x1ZGVzIHRoZQo+ICsgICAgbmVjZXNzYXJ5IHBhcmFtZXRlcnMg Zm9yIGNvbmZpZ3VyaW5nIGEgc3RhdGVsZXNzIGhhcmR3YXJlIGRlY29kaW5nCj4gKyAgICBwaXBl bGluZSBmb3IgSDI2NC4gIFRoZSBiaXRzdHJlYW0gcGFyYW1ldGVycyBhcmUgZGVmaW5lZCBhY2Nv cmRpbmcKPiArICAgIHRvIDpyZWY6YGgyNjRgLCBzZWN0aW9uIDcuNC4yLjIgIlBpY3R1cmUgUGFy YW1ldGVyIFNldCBSQlNQCj4gKyAgICBTZW1hbnRpY3MiLiBGb3IgZnVydGhlciBkb2N1bWVudGF0 aW9uLCByZWZlciB0byB0aGUgYWJvdmUKPiArICAgIHNwZWNpZmljYXRpb24sIHVubGVzcyB0aGVy ZSBpcyBhbiBleHBsaWNpdCBjb21tZW50IHN0YXRpbmcKPiArICAgIG90aGVyd2lzZS4KPiArCj4g KyAgICAuLiBub3RlOjoKPiArCj4gKyAgICAgICBUaGlzIGNvbXBvdW5kIGNvbnRyb2wgaXMgbm90 IHlldCBwYXJ0IG9mIHRoZSBwdWJsaWMga2VybmVsIEFQSSBhbmQKPiArICAgICAgIGl0IGlzIGV4 cGVjdGVkIHRvIGNoYW5nZS4KPiArCj4gKy4uIGM6dHlwZTo6IHY0bDJfY3RybF9oMjY0X3Bwcwo+ ICsKPiArLi4gY3NzY2xhc3M6OiBsb25ndGFibGUKPiArCj4gKy4uIGZsYXQtdGFibGU6OiBzdHJ1 Y3QgdjRsMl9jdHJsX2gyNjRfcHBzCj4gKyAgICA6aGVhZGVyLXJvd3M6ICAwCj4gKyAgICA6c3R1 Yi1jb2x1bW5zOiAwCj4gKyAgICA6d2lkdGhzOiAgICAgICAxIDEgMgo+ICsKPiArICAgICogLSBf X3U4Cj4gKyAgICAgIC0gYGBwaWNfcGFyYW1ldGVyX3NldF9pZGBgCj4gKyAgICAgIC0KPiArICAg ICogLSBfX3U4Cj4gKyAgICAgIC0gYGBzZXFfcGFyYW1ldGVyX3NldF9pZGBgCj4gKyAgICAgIC0K PiArICAgICogLSBfX3U4Cj4gKyAgICAgIC0gYGBudW1fc2xpY2VfZ3JvdXBzX21pbnVzMWBgCj4g KyAgICAgIC0KPiArICAgICogLSBfX3U4Cj4gKyAgICAgIC0gYGBudW1fcmVmX2lkeF9sMF9kZWZh dWx0X2FjdGl2ZV9taW51czFgYAo+ICsgICAgICAtCj4gKyAgICAqIC0gX191OAo+ICsgICAgICAt IGBgbnVtX3JlZl9pZHhfbDFfZGVmYXVsdF9hY3RpdmVfbWludXMxYGAKPiArICAgICAgLQo+ICsg ICAgKiAtIF9fdTgKPiArICAgICAgLSBgYHdlaWdodGVkX2JpcHJlZF9pZGNgYAo+ICsgICAgICAt Cj4gKyAgICAqIC0gX19zOAo+ICsgICAgICAtIGBgcGljX2luaXRfcXBfbWludXMyNmBgCj4gKyAg ICAgIC0KPiArICAgICogLSBfX3M4Cj4gKyAgICAgIC0gYGBwaWNfaW5pdF9xc19taW51czI2YGAK PiArICAgICAgLQo+ICsgICAgKiAtIF9fczgKPiArICAgICAgLSBgYGNocm9tYV9xcF9pbmRleF9v ZmZzZXRgYAo+ICsgICAgICAtCj4gKyAgICAqIC0gX19zOAo+ICsgICAgICAtIGBgc2Vjb25kX2No cm9tYV9xcF9pbmRleF9vZmZzZXRgYAo+ICsgICAgICAtCj4gKyAgICAqIC0gX191MTYKPiArICAg ICAgLSBgYGZsYWdzYGAKPiArICAgICAgLSBTZWUgOnJlZjpgUGljdHVyZSBQYXJhbWV0ZXIgU2V0 IEZsYWdzIDxoMjY0X3Bwc19mbGFncz5gCj4gKwo+ICsuLiBfaDI2NF9wcHNfZmxhZ3M6Cj4gKwo+ ICtgYFBpY3R1cmUgUGFyYW1ldGVyIFNldCBGbGFnc2BgCj4gKwo+ICsuLiBjc3NjbGFzczo6IGxv bmd0YWJsZQo+ICsKPiArLi4gZmxhdC10YWJsZTo6Cj4gKyAgICA6aGVhZGVyLXJvd3M6ICAwCj4g KyAgICA6c3R1Yi1jb2x1bW5zOiAwCj4gKyAgICA6d2lkdGhzOiAgICAgICAxIDEgMgo+ICsKPiAr ICAgICogLSBgYFY0TDJfSDI2NF9QUFNfRkxBR19FTlRST1BZX0NPRElOR19NT0RFYGAKPiArICAg ICAgLSAweDAwMDAwMDAxCj4gKyAgICAgIC0KPiArICAgICogLSBgYFY0TDJfSDI2NF9QUFNfRkxB R19CT1RUT01fRklFTERfUElDX09SREVSX0lOX0ZSQU1FX1BSRVNFTlRgYAo+ICsgICAgICAtIDB4 MDAwMDAwMDIKPiArICAgICAgLQo+ICsgICAgKiAtIGBgVjRMMl9IMjY0X1BQU19GTEFHX1dFSUdI VEVEX1BSRURgYAo+ICsgICAgICAtIDB4MDAwMDAwMDQKPiArICAgICAgLQo+ICsgICAgKiAtIGBg VjRMMl9IMjY0X1BQU19GTEFHX0RFQkxPQ0tJTkdfRklMVEVSX0NPTlRST0xfUFJFU0VOVGBgCj4g KyAgICAgIC0gMHgwMDAwMDAwOAo+ICsgICAgICAtCj4gKyAgICAqIC0gYGBWNEwyX0gyNjRfUFBT X0ZMQUdfQ09OU1RSQUlORURfSU5UUkFfUFJFRGBgCj4gKyAgICAgIC0gMHgwMDAwMDAxMAo+ICsg ICAgICAtCj4gKyAgICAqIC0gYGBWNEwyX0gyNjRfUFBTX0ZMQUdfUkVEVU5EQU5UX1BJQ19DTlRf UFJFU0VOVGBgCj4gKyAgICAgIC0gMHgwMDAwMDAyMAo+ICsgICAgICAtCj4gKyAgICAqIC0gYGBW NEwyX0gyNjRfUFBTX0ZMQUdfVFJBTlNGT1JNXzhYOF9NT0RFYGAKPiArICAgICAgLSAweDAwMDAw MDQwCj4gKyAgICAgIC0KPiArICAgICogLSBgYFY0TDJfSDI2NF9QUFNfRkxBR19QSUNfU0NBTElO R19NQVRSSVhfUFJFU0VOVGBgCj4gKyAgICAgIC0gMHgwMDAwMDA4MAo+ICsgICAgICAtCj4gKwo+ ICtgYFY0TDJfQ0lEX01QRUdfVklERU9fSDI2NF9TQ0FMSU5HX01BVFJJWCAoc3RydWN0KWBgCj4g KyAgICBTcGVjaWZpZXMgdGhlIHNjYWxpbmcgbWF0cml4IChhcyBleHRyYWN0ZWQgZnJvbSB0aGUg Yml0c3RyZWFtKSBmb3IKPiArICAgIHRoZSBhc3NvY2lhdGVkIEgyNjQgc2xpY2UgZGF0YS4gVGhl IGJpdHN0cmVhbSBwYXJhbWV0ZXJzIGFyZQo+ICsgICAgZGVmaW5lZCBhY2NvcmRpbmcgdG8gOnJl ZjpgaDI2NGAsIHNlY3Rpb24gNy40LjIuMS4xLjEgIlNjYWxpbmcKPiArICAgIExpc3QgU2VtYW50 aWNzIi5Gb3IgZnVydGhlciBkb2N1bWVudGF0aW9uLCByZWZlciB0byB0aGUgYWJvdmUKPiArICAg IHNwZWNpZmljYXRpb24sIHVubGVzcyB0aGVyZSBpcyBhbiBleHBsaWNpdCBjb21tZW50IHN0YXRp bmcKPiArICAgIG90aGVyd2lzZS4KPiArCj4gKyAgICAuLiBub3RlOjoKPiArCj4gKyAgICAgICBU aGlzIGNvbXBvdW5kIGNvbnRyb2wgaXMgbm90IHlldCBwYXJ0IG9mIHRoZSBwdWJsaWMga2VybmVs IEFQSSBhbmQKPiArICAgICAgIGl0IGlzIGV4cGVjdGVkIHRvIGNoYW5nZS4KPiArCj4gKy4uIGM6 dHlwZTo6IHY0bDJfY3RybF9oMjY0X3NjYWxpbmdfbWF0cml4Cj4gKwo+ICsuLiBjc3NjbGFzczo6 IGxvbmd0YWJsZQo+ICsKPiArLi4gZmxhdC10YWJsZTo6IHN0cnVjdCB2NGwyX2N0cmxfaDI2NF9z Y2FsaW5nX21hdHJpeAo+ICsgICAgOmhlYWRlci1yb3dzOiAgMAo+ICsgICAgOnN0dWItY29sdW1u czogMAo+ICsgICAgOndpZHRoczogICAgICAgMSAxIDIKPiArCj4gKyAgICAqIC0gX191OAo+ICsg ICAgICAtIGBgc2NhbGluZ19saXN0XzR4NFs2XVsxNl1gYAo+ICsgICAgICAtCj4gKyAgICAqIC0g X191OAo+ICsgICAgICAtIGBgc2NhbGluZ19saXN0Xzh4OFs2XVs2NF1gYAo+ICsgICAgICAtCj4g Kwo+ICtgYFY0TDJfQ0lEX01QRUdfVklERU9fSDI2NF9TTElDRV9QQVJBTVMgKHN0cnVjdClgYAo+ ICsgICAgU3BlY2lmaWVzIHRoZSBzbGljZSBwYXJhbWV0ZXJzIChhcyBleHRyYWN0ZWQgZnJvbSB0 aGUgYml0c3RyZWFtKQo+ICsgICAgZm9yIHRoZSBhc3NvY2lhdGVkIEgyNjQgc2xpY2UgZGF0YS4g VGhpcyBpbmNsdWRlcyB0aGUgbmVjZXNzYXJ5Cj4gKyAgICBwYXJhbWV0ZXJzIGZvciBjb25maWd1 cmluZyBhIHN0YXRlbGVzcyBoYXJkd2FyZSBkZWNvZGluZyBwaXBlbGluZQo+ICsgICAgZm9yIEgy NjQuICBUaGUgYml0c3RyZWFtIHBhcmFtZXRlcnMgYXJlIGRlZmluZWQgYWNjb3JkaW5nIHRvCj4g KyAgICA6cmVmOmBoMjY0YCwgc2VjdGlvbiA3LjQuMyAiU2xpY2UgSGVhZGVyIFNlbWFudGljcyIu IEZvciBmdXJ0aGVyCj4gKyAgICBkb2N1bWVudGF0aW9uLCByZWZlciB0byB0aGUgYWJvdmUgc3Bl Y2lmaWNhdGlvbiwgdW5sZXNzIHRoZXJlIGlzCj4gKyAgICBhbiBleHBsaWNpdCBjb21tZW50IHN0 YXRpbmcgb3RoZXJ3aXNlLgo+ICsKPiArICAgIC4uIG5vdGU6Ogo+ICsKPiArICAgICAgIFRoaXMg Y29tcG91bmQgY29udHJvbCBpcyBub3QgeWV0IHBhcnQgb2YgdGhlIHB1YmxpYyBrZXJuZWwgQVBJ Cj4gKyAgICAgICBhbmQgaXQgaXMgZXhwZWN0ZWQgdG8gY2hhbmdlLgo+ICsKPiArICAgICAgIFRo aXMgc3RydWN0dXJlIGlzIGV4cGVjdGVkIHRvIGJlIHBhc3NlZCBhcyBhbiBhcnJheSwgd2l0aCBv bmUKPiArICAgICAgIGVudHJ5IGZvciBlYWNoIHNsaWNlIGluY2x1ZGVkIGluIHRoZSBiaXRzdHJl YW0gYnVmZmVyLgo+ICsKPiArLi4gYzp0eXBlOjogdjRsMl9jdHJsX2gyNjRfc2xpY2VfcGFyYW1z Cj4gKwo+ICsuLiBjc3NjbGFzczo6IGxvbmd0YWJsZQo+ICsKPiArLi4gZmxhdC10YWJsZTo6IHN0 cnVjdCB2NGwyX2N0cmxfaDI2NF9zbGljZV9wYXJhbXMKPiArICAgIDpoZWFkZXItcm93czogIDAK PiArICAgIDpzdHViLWNvbHVtbnM6IDAKPiArICAgIDp3aWR0aHM6ICAgICAgIDEgMSAyCj4gKwo+ ICsgICAgKiAtIF9fdTMyCj4gKyAgICAgIC0gYGBzaXplYGAKPiArICAgICAgLQo+ICsgICAgKiAt IF9fdTMyCj4gKyAgICAgIC0gYGBoZWFkZXJfYml0X3NpemVgYAo+ICsgICAgICAtCj4gKyAgICAq IC0gX191MTYKPiArICAgICAgLSBgYGZpcnN0X21iX2luX3NsaWNlYGAKPiArICAgICAgLQo+ICsg ICAgKiAtIF9fdTgKPiArICAgICAgLSBgYHNsaWNlX3R5cGVgYAo+ICsgICAgICAtCj4gKyAgICAq IC0gX191OAo+ICsgICAgICAtIGBgcGljX3BhcmFtZXRlcl9zZXRfaWRgYAo+ICsgICAgICAtCj4g KyAgICAqIC0gX191OAo+ICsgICAgICAtIGBgY29sb3VyX3BsYW5lX2lkYGAKPiArICAgICAgLQo+ ICsgICAgKiAtIF9fdTgKPiArICAgICAgLSBgYHJlZHVuZGFudF9waWNfY250YGAKPiArICAgICAg LQo+ICsgICAgKiAtIF9fdTE2Cj4gKyAgICAgIC0gYGBmcmFtZV9udW1gYAo+ICsgICAgICAtCj4g KyAgICAqIC0gX191MTYKPiArICAgICAgLSBgYGlkcl9waWNfaWRgYAo+ICsgICAgICAtCj4gKyAg ICAqIC0gX191MTYKPiArICAgICAgLSBgYHBpY19vcmRlcl9jbnRfbHNiYGAKPiArICAgICAgLQo+ ICsgICAgKiAtIF9fczMyCj4gKyAgICAgIC0gYGBkZWx0YV9waWNfb3JkZXJfY250X2JvdHRvbWBg Cj4gKyAgICAgIC0KPiArICAgICogLSBfX3MzMgo+ICsgICAgICAtIGBgZGVsdGFfcGljX29yZGVy X2NudDBgYAo+ICsgICAgICAtCj4gKyAgICAqIC0gX19zMzIKPiArICAgICAgLSBgYGRlbHRhX3Bp Y19vcmRlcl9jbnQxYGAKPiArICAgICAgLQo+ICsgICAgKiAtIHN0cnVjdCA6Yzp0eXBlOmB2NGwy X2gyNjRfcHJlZF93ZWlnaHRfdGFibGVgCj4gKyAgICAgIC0gYGBwcmVkX3dlaWdodF90YWJsZWBg Cj4gKyAgICAgIC0KPiArICAgICogLSBfX3UzMgo+ICsgICAgICAtIGBgZGVjX3JlZl9waWNfbWFy a2luZ19iaXRfc2l6ZWBgCj4gKyAgICAgIC0KPiArICAgICogLSBfX3UzMgo+ICsgICAgICAtIGBg cGljX29yZGVyX2NudF9iaXRfc2l6ZWBgCj4gKyAgICAgIC0KPiArICAgICogLSBfX3U4Cj4gKyAg ICAgIC0gYGBjYWJhY19pbml0X2lkY2BgCj4gKyAgICAgIC0KPiArICAgICogLSBfX3M4Cj4gKyAg ICAgIC0gYGBzbGljZV9xcF9kZWx0YWBgCj4gKyAgICAgIC0KPiArICAgICogLSBfX3M4Cj4gKyAg ICAgIC0gYGBzbGljZV9xc19kZWx0YWBgCj4gKyAgICAgIC0KPiArICAgICogLSBfX3U4Cj4gKyAg ICAgIC0gYGBkaXNhYmxlX2RlYmxvY2tpbmdfZmlsdGVyX2lkY2BgCj4gKyAgICAgIC0KPiArICAg ICogLSBfX3M4Cj4gKyAgICAgIC0gYGBzbGljZV9hbHBoYV9jMF9vZmZzZXRfZGl2MmBgCj4gKyAg ICAgIC0KPiArICAgICogLSBfX3M4Cj4gKyAgICAgIC0gYGBzbGljZV9iZXRhX29mZnNldF9kaXYy YGAKPiArICAgICAgLQo+ICsgICAgKiAtIF9fdTgKPiArICAgICAgLSBgYG51bV9yZWZfaWR4X2ww X2FjdGl2ZV9taW51czFgYAo+ICsgICAgICAtCj4gKyAgICAqIC0gX191OAo+ICsgICAgICAtIGBg bnVtX3JlZl9pZHhfbDFfYWN0aXZlX21pbnVzMWBgCj4gKyAgICAgIC0KPiArICAgICogLSBfX3Uz Mgo+ICsgICAgICAtIGBgc2xpY2VfZ3JvdXBfY2hhbmdlX2N5Y2xlYGAKPiArICAgICAgLQo+ICsg ICAgKiAtIF9fdTgKPiArICAgICAgLSBgYHJlZl9waWNfbGlzdDBbMzJdYGAKPiArICAgICAgLSBS ZWZlcmVuY2UgcGljdHVyZSBsaXN0IGFmdGVyIGFwcGx5aW5nIHRoZSBwZXItc2xpY2UgbW9kaWZp Y2F0aW9ucwo+ICsgICAgKiAtIF9fdTgKPiArICAgICAgLSBgYHJlZl9waWNfbGlzdDFbMzJdYGAK PiArICAgICAgLSBSZWZlcmVuY2UgcGljdHVyZSBsaXN0IGFmdGVyIGFwcGx5aW5nIHRoZSBwZXIt c2xpY2UgbW9kaWZpY2F0aW9ucwo+ICsgICAgKiAtIF9fdTMyCj4gKyAgICAgIC0gYGBmbGFnc2Bg Cj4gKyAgICAgIC0gU2VlIDpyZWY6YFNsaWNlIFBhcmFtZXRlciBGbGFncyA8aDI2NF9zbGljZV9m bGFncz5gCj4gKwo+ICsuLiBfaDI2NF9zbGljZV9mbGFnczoKPiArCj4gK2BgU2xpY2UgUGFyYW1l dGVyIFNldCBGbGFnc2BgCj4gKwo+ICsuLiBjc3NjbGFzczo6IGxvbmd0YWJsZQo+ICsKPiArLi4g ZmxhdC10YWJsZTo6Cj4gKyAgICA6aGVhZGVyLXJvd3M6ICAwCj4gKyAgICA6c3R1Yi1jb2x1bW5z OiAwCj4gKyAgICA6d2lkdGhzOiAgICAgICAxIDEgMgo+ICsKPiArICAgICogLSBgYFY0TDJfSDI2 NF9TTElDRV9GTEFHX0ZJRUxEX1BJQ2BgCj4gKyAgICAgIC0gMHgwMDAwMDAwMQo+ICsgICAgICAt Cj4gKyAgICAqIC0gYGBWNEwyX0gyNjRfU0xJQ0VfRkxBR19CT1RUT01fRklFTERgYAo+ICsgICAg ICAtIDB4MDAwMDAwMDIKPiArICAgICAgLQo+ICsgICAgKiAtIGBgVjRMMl9IMjY0X1NMSUNFX0ZM QUdfRElSRUNUX1NQQVRJQUxfTVZfUFJFRGBgCj4gKyAgICAgIC0gMHgwMDAwMDAwNAo+ICsgICAg ICAtCj4gKyAgICAqIC0gYGBWNEwyX0gyNjRfU0xJQ0VfRkxBR19TUF9GT1JfU1dJVENIYGAKPiAr ICAgICAgLSAweDAwMDAwMDA4Cj4gKyAgICAgIC0KPiArCj4gK2BgUHJlZGljdGlvbiBXZWlnaHQg VGFibGVgYAo+ICsKPiArICAgIFRoZSBiaXRzdHJlYW0gcGFyYW1ldGVycyBhcmUgZGVmaW5lZCBh Y2NvcmRpbmcgdG8gOnJlZjpgaDI2NGAsCj4gKyAgICBzZWN0aW9uIDcuNC4zLjIgIlByZWRpY3Rp b24gV2VpZ2h0IFRhYmxlIFNlbWFudGljcyIuIEZvciBmdXJ0aGVyCj4gKyAgICBkb2N1bWVudGF0 aW9uLCByZWZlciB0byB0aGUgYWJvdmUgc3BlY2lmaWNhdGlvbiwgdW5sZXNzIHRoZXJlIGlzCj4g KyAgICBhbiBleHBsaWNpdCBjb21tZW50IHN0YXRpbmcgb3RoZXJ3aXNlLgo+ICsKPiArLi4gYzp0 eXBlOjogdjRsMl9oMjY0X3ByZWRfd2VpZ2h0X3RhYmxlCj4gKwo+ICsuLiBjc3NjbGFzczo6IGxv bmd0YWJsZQo+ICsKPiArLi4gZmxhdC10YWJsZTo6IHN0cnVjdCB2NGwyX2gyNjRfcHJlZF93ZWln aHRfdGFibGUKPiArICAgIDpoZWFkZXItcm93czogIDAKPiArICAgIDpzdHViLWNvbHVtbnM6IDAK PiArICAgIDp3aWR0aHM6ICAgICAgIDEgMSAyCj4gKwo+ICsgICAgKiAtIF9fdTE2Cj4gKyAgICAg IC0gYGBsdW1hX2xvZzJfd2VpZ2h0X2Rlbm9tYGAKPiArICAgICAgLQo+ICsgICAgKiAtIF9fdTE2 Cj4gKyAgICAgIC0gYGBjaHJvbWFfbG9nMl93ZWlnaHRfZGVub21gYAo+ICsgICAgICAtCj4gKyAg ICAqIC0gc3RydWN0IDpjOnR5cGU6YHY0bDJfaDI2NF93ZWlnaHRfZmFjdG9yc2AKPiArICAgICAg LSBgYHdlaWdodF9mYWN0b3JzWzJdYGAKPiArICAgICAgLSBUaGUgd2VpZ2h0IGZhY3RvcnMgYXQg aW5kZXggMCBhcmUgdGhlIHdlaWdodCBmYWN0b3JzIGZvciB0aGUgcmVmZXJlbmNlCj4gKyAgICAg ICAgbGlzdCAwLCB0aGUgb25lIGF0IGluZGV4IDEgZm9yIHRoZSByZWZlcmVuY2UgbGlzdCAxLgo+ ICsKPiArLi4gYzp0eXBlOjogdjRsMl9oMjY0X3dlaWdodF9mYWN0b3JzCj4gKwo+ICsuLiBjc3Nj bGFzczo6IGxvbmd0YWJsZQo+ICsKPiArLi4gZmxhdC10YWJsZTo6IHN0cnVjdCB2NGwyX2gyNjRf d2VpZ2h0X2ZhY3RvcnMKPiArICAgIDpoZWFkZXItcm93czogIDAKPiArICAgIDpzdHViLWNvbHVt bnM6IDAKPiArICAgIDp3aWR0aHM6ICAgICAgIDEgMSAyCj4gKwo+ICsgICAgKiAtIF9fczE2Cj4g KyAgICAgIC0gYGBsdW1hX3dlaWdodFszMl1gYAo+ICsgICAgICAtCj4gKyAgICAqIC0gX19zMTYK PiArICAgICAgLSBgYGx1bWFfb2Zmc2V0WzMyXWBgCj4gKyAgICAgIC0KPiArICAgICogLSBfX3Mx Ngo+ICsgICAgICAtIGBgY2hyb21hX3dlaWdodFszMl1bMl1gYAo+ICsgICAgICAtCj4gKyAgICAq IC0gX19zMTYKPiArICAgICAgLSBgYGNocm9tYV9vZmZzZXRbMzJdWzJdYGAKPiArICAgICAgLQo+ ICsKPiArYGBWNEwyX0NJRF9NUEVHX1ZJREVPX0gyNjRfREVDT0RFX1BBUkFNUyAoc3RydWN0KWBg Cj4gKyAgICBTcGVjaWZpZXMgdGhlIGRlY29kZSBwYXJhbWV0ZXJzIChhcyBleHRyYWN0ZWQgZnJv bSB0aGUgYml0c3RyZWFtKQo+ICsgICAgZm9yIHRoZSBhc3NvY2lhdGVkIEgyNjQgc2xpY2UgZGF0 YS4gVGhpcyBpbmNsdWRlcyB0aGUgbmVjZXNzYXJ5Cj4gKyAgICBwYXJhbWV0ZXJzIGZvciBjb25m aWd1cmluZyBhIHN0YXRlbGVzcyBoYXJkd2FyZSBkZWNvZGluZyBwaXBlbGluZQo+ICsgICAgZm9y IEgyNjQuIFRoZSBiaXRzdHJlYW0gcGFyYW1ldGVycyBhcmUgZGVmaW5lZCBhY2NvcmRpbmcgdG8K PiArICAgIDpyZWY6YGgyNjRgLiBGb3IgZnVydGhlciBkb2N1bWVudGF0aW9uLCByZWZlciB0byB0 aGUgYWJvdmUKPiArICAgIHNwZWNpZmljYXRpb24sIHVubGVzcyB0aGVyZSBpcyBhbiBleHBsaWNp dCBjb21tZW50IHN0YXRpbmcKPiArICAgIG90aGVyd2lzZS4KPiArCj4gKyAgICAuLiBub3RlOjoK PiArCj4gKyAgICAgICBUaGlzIGNvbXBvdW5kIGNvbnRyb2wgaXMgbm90IHlldCBwYXJ0IG9mIHRo ZSBwdWJsaWMga2VybmVsIEFQSSBhbmQKPiArICAgICAgIGl0IGlzIGV4cGVjdGVkIHRvIGNoYW5n ZS4KPiArCj4gKy4uIGM6dHlwZTo6IHY0bDJfY3RybF9oMjY0X2RlY29kZV9wYXJhbXMKPiArCj4g Ky4uIGNzc2NsYXNzOjogbG9uZ3RhYmxlCj4gKwo+ICsuLiBmbGF0LXRhYmxlOjogc3RydWN0IHY0 bDJfY3RybF9oMjY0X2RlY29kZV9wYXJhbXMKPiArICAgIDpoZWFkZXItcm93czogIDAKPiArICAg IDpzdHViLWNvbHVtbnM6IDAKPiArICAgIDp3aWR0aHM6ICAgICAgIDEgMSAyCj4gKwo+ICsgICAg KiAtIF9fdTMyCj4gKyAgICAgIC0gYGBudW1fc2xpY2VzYGAKPiArICAgICAgLSBOdW1iZXIgb2Yg c2xpY2VzIG5lZWRlZCB0byBkZWNvZGUgdGhlIGN1cnJlbnQgZnJhbWUKPiArICAgICogLSBfX3Uz Mgo+ICsgICAgICAtIGBgbmFsX3JlZl9pZGNgYAo+ICsgICAgICAtIE5BTCByZWZlcmVuY2UgSUQg dmFsdWUgY29taW5nIGZyb20gdGhlIE5BTCBVbml0IGhlYWRlcgo+ICsgICAgKiAtIF9fdTgKPiAr ICAgICAgLSBgYHJlZl9waWNfbGlzdF9wMFszMl1gYAo+ICsgICAgICAtIEJhY2t3YXJkIHJlZmVy ZW5jZSBsaXN0IHVzZWQgYnkgUC1mcmFtZXMgaW4gdGhlIG9yaWdpbmFsIGJpdHN0cmVhbSBvcmRl cgo+ICsgICAgKiAtIF9fdTgKPiArICAgICAgLSBgYHJlZl9waWNfbGlzdF9iMFszMl1gYAo+ICsg ICAgICAtIEJhY2t3YXJkIHJlZmVyZW5jZSBsaXN0IHVzZWQgYnkgQi1mcmFtZXMgaW4gdGhlIG9y aWdpbmFsIGJpdHN0cmVhbSBvcmRlcgo+ICsgICAgKiAtIF9fdTgKPiArICAgICAgLSBgYHJlZl9w aWNfbGlzdF9iMVszMl1gYAo+ICsgICAgICAtIEZvcndhcmQgcmVmZXJlbmNlIGxpc3QgdXNlZCBi eSBCLWZyYW1lcyBpbiB0aGUgb3JpZ2luYWwgYml0c3RyZWFtIG9yZGVyCj4gKyAgICAqIC0gX19z MzIKPiArICAgICAgLSBgYHRvcF9maWVsZF9vcmRlcl9jbnRgYAo+ICsgICAgICAtIFBpY3R1cmUg T3JkZXIgQ291bnQgZm9yIHRoZSBjb2RlZCB0b3AgZmllbGQKPiArICAgICogLSBfX3MzMgo+ICsg ICAgICAtIGBgYm90dG9tX2ZpZWxkX29yZGVyX2NudGBgCj4gKyAgICAgIC0gUGljdHVyZSBPcmRl ciBDb3VudCBmb3IgdGhlIGNvZGVkIGJvdHRvbSBmaWVsZAo+ICsgICAgKiAtIF9fdTMyCj4gKyAg ICAgIC0gYGBmbGFnc2BgCj4gKyAgICAgIC0gU2VlIDpyZWY6YERlY29kZSBQYXJhbWV0ZXJzIEZs YWdzIDxoMjY0X2RlY29kZV9wYXJhbXNfZmxhZ3M+YAo+ICsgICAgKiAtIHN0cnVjdCA6Yzp0eXBl OmB2NGwyX2gyNjRfZHBiX2VudHJ5YAo+ICsgICAgICAtIGBgZHBiWzE2XWBgCj4gKyAgICAgIC0K PiArCj4gKy4uIF9oMjY0X2RlY29kZV9wYXJhbXNfZmxhZ3M6Cj4gKwo+ICtgYERlY29kZSBQYXJh bWV0ZXJzIEZsYWdzYGAKPiArCj4gKy4uIGNzc2NsYXNzOjogbG9uZ3RhYmxlCj4gKwo+ICsuLiBm bGF0LXRhYmxlOjoKPiArICAgIDpoZWFkZXItcm93czogIDAKPiArICAgIDpzdHViLWNvbHVtbnM6 IDAKPiArICAgIDp3aWR0aHM6ICAgICAgIDEgMSAyCj4gKwo+ICsgICAgKiAtIGBgVjRMMl9IMjY0 X0RFQ09ERV9QQVJBTV9GTEFHX0lEUl9QSUNgYAo+ICsgICAgICAtIDB4MDAwMDAwMDEKPiArICAg ICAgLSBUaGF0IHBpY3R1cmUgaXMgYW4gSURSIHBpY3R1cmUKPiArCj4gKy4uIGM6dHlwZTo6IHY0 bDJfaDI2NF9kcGJfZW50cnkKPiArCj4gKy4uIGNzc2NsYXNzOjogbG9uZ3RhYmxlCj4gKwo+ICsu LiBmbGF0LXRhYmxlOjogc3RydWN0IHY0bDJfaDI2NF9kcGJfZW50cnkKPiArICAgIDpoZWFkZXIt cm93czogIDAKPiArICAgIDpzdHViLWNvbHVtbnM6IDAKPiArICAgIDp3aWR0aHM6ICAgICAgIDEg MSAyCj4gKwo+ICsgICAgKiAtIF9fdTY0Cj4gKyAgICAgIC0gYGByZWZlcmVuY2VfdHNgYAo+ICsg ICAgICAtIFRpbWVzdGFtcCBvZiB0aGUgVjRMMiBjYXB0dXJlIGJ1ZmZlciB0byB1c2UgYXMgcmVm ZXJlbmNlLCB1c2VkCj4gKyAgICAgICAgd2l0aCBCLWNvZGVkIGFuZCBQLWNvZGVkIGZyYW1lcy4g VGhlIHRpbWVzdGFtcCByZWZlcnMgdG8gdGhlCj4gKwlgYHRpbWVzdGFtcGBgIGZpZWxkIGluIHN0 cnVjdCA6Yzp0eXBlOmB2NGwyX2J1ZmZlcmAuIFVzZSB0aGUKPiArCTpjOmZ1bmM6YHY0bDJfdGlt ZXZhbF90b19ucygpYCBmdW5jdGlvbiB0byBjb252ZXJ0IHRoZSBzdHJ1Y3QKPiArCTpjOnR5cGU6 YHRpbWV2YWxgIGluIHN0cnVjdCA6Yzp0eXBlOmB2NGwyX2J1ZmZlcmAgdG8gYSBfX3U2NC4KPiAr ICAgICogLSBfX3UxNgo+ICsgICAgICAtIGBgZnJhbWVfbnVtYGAKPiArICAgICAgLQo+ICsgICAg KiAtIF9fdTE2Cj4gKyAgICAgIC0gYGBwaWNfbnVtYGAKPiArICAgICAgLQo+ICsgICAgKiAtIF9f czMyCj4gKyAgICAgIC0gYGB0b3BfZmllbGRfb3JkZXJfY250YGAKPiArICAgICAgLQo+ICsgICAg KiAtIF9fczMyCj4gKyAgICAgIC0gYGBib3R0b21fZmllbGRfb3JkZXJfY250YGAKPiArICAgICAg LQo+ICsgICAgKiAtIF9fdTMyCj4gKyAgICAgIC0gYGBmbGFnc2BgCj4gKyAgICAgIC0gU2VlIDpy ZWY6YERQQiBFbnRyeSBGbGFncyA8aDI2NF9kcGJfZmxhZ3M+YAo+ICsKPiArLi4gX2gyNjRfZHBi X2ZsYWdzOgo+ICsKPiArYGBEUEIgRW50cmllcyBGbGFnc2BgCj4gKwo+ICsuLiBjc3NjbGFzczo6 IGxvbmd0YWJsZQo+ICsKPiArLi4gZmxhdC10YWJsZTo6Cj4gKyAgICA6aGVhZGVyLXJvd3M6ICAw Cj4gKyAgICA6c3R1Yi1jb2x1bW5zOiAwCj4gKyAgICA6d2lkdGhzOiAgICAgICAxIDEgMgo+ICsK PiArICAgICogLSBgYFY0TDJfSDI2NF9EUEJfRU5UUllfRkxBR19WQUxJRGBgCj4gKyAgICAgIC0g MHgwMDAwMDAwMQo+ICsgICAgICAtIFRoZSBEUEIgZW50cnkgaXMgdmFsaWQgYW5kIHNob3VsZCBi ZSBjb25zaWRlcmVkCj4gKyAgICAqIC0gYGBWNEwyX0gyNjRfRFBCX0VOVFJZX0ZMQUdfQUNUSVZF YGAKPiArICAgICAgLSAweDAwMDAwMDAyCj4gKyAgICAgIC0gVGhlIERQQiBlbnRyeSBpcyBjdXJy ZW50bHkgYmVpbmcgdXNlZCBhcyBhIHJlZmVyZW5jZSBmcmFtZQo+ICsgICAgKiAtIGBgVjRMMl9I MjY0X0RQQl9FTlRSWV9GTEFHX0xPTkdfVEVSTWBgCj4gKyAgICAgIC0gMHgwMDAwMDAwNAo+ICsg ICAgICAtIFRoZSBEUEIgZW50cnkgaXMgYSBsb25nIHRlcm0gcmVmZXJlbmNlIGZyYW1lCj4gIAo+ ICAuLiBfdjRsMi1tcGVnLW1wZWcyOgo+ICAKPiBkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9t ZWRpYS91YXBpL3Y0bC9waXhmbXQtY29tcHJlc3NlZC5yc3QgYi9Eb2N1bWVudGF0aW9uL21lZGlh L3VhcGkvdjRsL3BpeGZtdC1jb21wcmVzc2VkLnJzdAo+IGluZGV4IDZjOTYxY2ZiNzRkYS4uZWEw YThhNjg3NTliIDEwMDY0NAo+IC0tLSBhL0RvY3VtZW50YXRpb24vbWVkaWEvdWFwaS92NGwvcGl4 Zm10LWNvbXByZXNzZWQucnN0Cj4gKysrIGIvRG9jdW1lbnRhdGlvbi9tZWRpYS91YXBpL3Y0bC9w aXhmbXQtY29tcHJlc3NlZC5yc3QKPiBAQCAtNTIsNiArNTIsMjUgQEAgQ29tcHJlc3NlZCBGb3Jt YXRzCj4gICAgICAgIC0gYGBWNEwyX1BJWF9GTVRfSDI2NF9NVkNgYAo+ICAgICAgICAtICdNMjY0 Jwo+ICAgICAgICAtIEgyNjQgTVZDIHZpZGVvIGVsZW1lbnRhcnkgc3RyZWFtLgo+ICsgICAgKiAu LiBfVjRMMi1QSVgtRk1ULUgyNjQtU0xJQ0U6Cj4gKwo+ICsgICAgICAtIGBgVjRMMl9QSVhfRk1U X0gyNjRfU0xJQ0VfUkFXYGAKPiArICAgICAgLSAnUzI2NCcKPiArICAgICAgLSBIMjY0IHBhcnNl ZCBzbGljZSBkYXRhLCBhcyBleHRyYWN0ZWQgZnJvbSB0aGUgSDI2NCBiaXRzdHJlYW0uCj4gKwlU aGlzIGZvcm1hdCBpcyBhZGFwdGVkIGZvciBzdGF0ZWxlc3MgdmlkZW8gZGVjb2RlcnMgdGhhdAo+ ICsJaW1wbGVtZW50IGFuIEgyNjQgcGlwZWxpbmUgKHVzaW5nIHRoZSA6cmVmOmBjb2RlY2AgYW5k Cj4gKwk6cmVmOmBtZWRpYS1yZXF1ZXN0LWFwaWApLiAgTWV0YWRhdGEgYXNzb2NpYXRlZCB3aXRo IHRoZSBmcmFtZQo+ICsJdG8gZGVjb2RlIGFyZSByZXF1aXJlZCB0byBiZSBwYXNzZWQgdGhyb3Vn aCB0aGUKPiArCWBgVjRMMl9DSURfTVBFR19WSURFT19IMjY0X1NQU2BgLAo+ICsJYGBWNEwyX0NJ RF9NUEVHX1ZJREVPX0gyNjRfUFBTYGAsCj4gKwlgYFY0TDJfQ0lEX01QRUdfVklERU9fSDI2NF9T Q0FMSU5HX01BVFJJWGBgLAo+ICsJYGBWNEwyX0NJRF9NUEVHX1ZJREVPX0gyNjRfU0xJQ0VfUEFS QU1TYGAgYW5kCj4gKwlgYFY0TDJfQ0lEX01QRUdfVklERU9fSDI2NF9ERUNPREVfUEFSQU1TYGAg Y29udHJvbHMuICBTZWUgdGhlCj4gKwk6cmVmOmBhc3NvY2lhdGVkIENvZGVjIENvbnRyb2wgSURz IDx2NGwyLW1wZWctaDI2ND5gLgo+ICsJRXhhY3RseSBvbmUgb3V0cHV0IGFuZCBvbmUgY2FwdHVy ZSBidWZmZXIgbXVzdCBiZSBwcm92aWRlZCBmb3IKPiArCXVzZSB3aXRoIHRoaXMgcGl4ZWwgZm9y bWF0LiBUaGUgb3V0cHV0IGJ1ZmZlciBtdXN0IGNvbnRhaW4gdGhlCj4gKwlhcHByb3ByaWF0ZSBu dW1iZXIgb2YgbWFjcm9ibG9ja3MgdG8gZGVjb2RlIGEgZnVsbAo+ICsJY29ycmVzcG9uZGluZyBm cmFtZSB0byB0aGUgbWF0Y2hpbmcgY2FwdHVyZSBidWZmZXIuCj4gICAgICAqIC4uIF9WNEwyLVBJ WC1GTVQtSDI2MzoKPiAgCj4gICAgICAgIC0gYGBWNEwyX1BJWF9GTVRfSDI2M2BgCj4gZGlmZiAt LWdpdCBhL0RvY3VtZW50YXRpb24vbWVkaWEvdWFwaS92NGwvdmlkaW9jLXF1ZXJ5Y3RybC5yc3Qg Yi9Eb2N1bWVudGF0aW9uL21lZGlhL3VhcGkvdjRsL3ZpZGlvYy1xdWVyeWN0cmwucnN0Cj4gaW5k ZXggZjgyNDE2MmQwZWE5Li5kYzUwMDYzMjA5NWQgMTAwNjQ0Cj4gLS0tIGEvRG9jdW1lbnRhdGlv bi9tZWRpYS91YXBpL3Y0bC92aWRpb2MtcXVlcnljdHJsLnJzdAo+ICsrKyBiL0RvY3VtZW50YXRp b24vbWVkaWEvdWFwaS92NGwvdmlkaW9jLXF1ZXJ5Y3RybC5yc3QKPiBAQCAtNDQzLDYgKzQ0Mywz NiBAQCBTZWUgYWxzbyB0aGUgZXhhbXBsZXMgaW4gOnJlZjpgY29udHJvbGAuCj4gICAgICAgIC0g bi9hCj4gICAgICAgIC0gQSBzdHJ1Y3QgOmM6dHlwZTpgdjRsMl9jdHJsX21wZWcyX3F1YW50aXph dGlvbmAsIGNvbnRhaW5pbmcgTVBFRy0yCj4gIAlxdWFudGl6YXRpb24gbWF0cmljZXMgZm9yIHN0 YXRlbGVzcyB2aWRlbyBkZWNvZGVycy4KPiArICAgICogLSBgYFY0TDJfQ1RSTF9UWVBFX0gyNjRf U1BTYGAKPiArICAgICAgLSBuL2EKPiArICAgICAgLSBuL2EKPiArICAgICAgLSBuL2EKPiArICAg ICAgLSBBIHN0cnVjdCA6Yzp0eXBlOmB2NGwyX2N0cmxfaDI2NF9zcHNgLCBjb250YWluaW5nIEgy NjQKPiArCXNlcXVlbmNlIHBhcmFtZXRlcnMgZm9yIHN0YXRlbGVzcyB2aWRlbyBkZWNvZGVycy4K PiArICAgICogLSBgYFY0TDJfQ1RSTF9UWVBFX0gyNjRfUFBTYGAKPiArICAgICAgLSBuL2EKPiAr ICAgICAgLSBuL2EKPiArICAgICAgLSBuL2EKPiArICAgICAgLSBBIHN0cnVjdCA6Yzp0eXBlOmB2 NGwyX2N0cmxfaDI2NF9wcHNgLCBjb250YWluaW5nIEgyNjQKPiArCXBpY3R1cmUgcGFyYW1ldGVy cyBmb3Igc3RhdGVsZXNzIHZpZGVvIGRlY29kZXJzLgo+ICsgICAgKiAtIGBgVjRMMl9DVFJMX1RZ UEVfSDI2NF9TQ0FMSU5HX01BVFJJWGBgCj4gKyAgICAgIC0gbi9hCj4gKyAgICAgIC0gbi9hCj4g KyAgICAgIC0gbi9hCj4gKyAgICAgIC0gQSBzdHJ1Y3QgOmM6dHlwZTpgdjRsMl9jdHJsX2gyNjRf c2NhbGluZ19tYXRyaXhgLCBjb250YWluaW5nIEgyNjQKPiArCXNjYWxpbmcgbWF0cmljZXMgZm9y IHN0YXRlbGVzcyB2aWRlbyBkZWNvZGVycy4KPiArICAgICogLSBgYFY0TDJfQ1RSTF9UWVBFX0gy NjRfU0xJQ0VfUEFSQU1TYGAKPiArICAgICAgLSBuL2EKPiArICAgICAgLSBuL2EKPiArICAgICAg LSBuL2EKPiArICAgICAgLSBBIHN0cnVjdCA6Yzp0eXBlOmB2NGwyX2N0cmxfaDI2NF9zbGljZV9w YXJhbXNgLCBjb250YWluaW5nIEgyNjQKPiArCXNsaWNlIHBhcmFtZXRlcnMgZm9yIHN0YXRlbGVz cyB2aWRlbyBkZWNvZGVycy4KPiArICAgICogLSBgYFY0TDJfQ1RSTF9UWVBFX0gyNjRfREVDT0RF X1BBUkFNU2BgCj4gKyAgICAgIC0gbi9hCj4gKyAgICAgIC0gbi9hCj4gKyAgICAgIC0gbi9hCj4g KyAgICAgIC0gQSBzdHJ1Y3QgOmM6dHlwZTpgdjRsMl9jdHJsX2gyNjRfZGVjb2RlX3BhcmFtc2As IGNvbnRhaW5pbmcgSDI2NAo+ICsJZGVjb2RlIHBhcmFtZXRlcnMgZm9yIHN0YXRlbGVzcyB2aWRl byBkZWNvZGVycy4KPiAgCj4gIC4uIHRhYnVsYXJjb2x1bW5zOjogfHB7Ni42Y219fHB7Mi4yY219 fHB7OC43Y219fAo+ICAKPiBkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9tZWRpYS92aWRlb2Rl djIuaC5yc3QuZXhjZXB0aW9ucyBiL0RvY3VtZW50YXRpb24vbWVkaWEvdmlkZW9kZXYyLmgucnN0 LmV4Y2VwdGlvbnMKPiBpbmRleCA2NGQzNDhlNjdkZjkuLjU1Y2JlMzI0YjlmYyAxMDA2NDQKPiAt LS0gYS9Eb2N1bWVudGF0aW9uL21lZGlhL3ZpZGVvZGV2Mi5oLnJzdC5leGNlcHRpb25zCj4gKysr IGIvRG9jdW1lbnRhdGlvbi9tZWRpYS92aWRlb2RldjIuaC5yc3QuZXhjZXB0aW9ucwo+IEBAIC0x MzYsNiArMTM2LDExIEBAIHJlcGxhY2Ugc3ltYm9sIFY0TDJfQ1RSTF9UWVBFX1UzMiA6Yzp0eXBl OmB2NGwyX2N0cmxfdHlwZWAKPiAgcmVwbGFjZSBzeW1ib2wgVjRMMl9DVFJMX1RZUEVfVTggOmM6 dHlwZTpgdjRsMl9jdHJsX3R5cGVgCj4gIHJlcGxhY2Ugc3ltYm9sIFY0TDJfQ1RSTF9UWVBFX01Q RUcyX1NMSUNFX1BBUkFNUyA6Yzp0eXBlOmB2NGwyX2N0cmxfdHlwZWAKPiAgcmVwbGFjZSBzeW1i b2wgVjRMMl9DVFJMX1RZUEVfTVBFRzJfUVVBTlRJWkFUSU9OIDpjOnR5cGU6YHY0bDJfY3RybF90 eXBlYAo+ICtyZXBsYWNlIHN5bWJvbCBWNEwyX0NUUkxfVFlQRV9IMjY0X1NQUyA6Yzp0eXBlOmB2 NGwyX2N0cmxfdHlwZWAKPiArcmVwbGFjZSBzeW1ib2wgVjRMMl9DVFJMX1RZUEVfSDI2NF9QUFMg OmM6dHlwZTpgdjRsMl9jdHJsX3R5cGVgCj4gK3JlcGxhY2Ugc3ltYm9sIFY0TDJfQ1RSTF9UWVBF X0gyNjRfU0NBTElOR19NQVRSSVggOmM6dHlwZTpgdjRsMl9jdHJsX3R5cGVgCj4gK3JlcGxhY2Ug c3ltYm9sIFY0TDJfQ1RSTF9UWVBFX0gyNjRfU0xJQ0VfUEFSQU1TIDpjOnR5cGU6YHY0bDJfY3Ry bF90eXBlYAo+ICtyZXBsYWNlIHN5bWJvbCBWNEwyX0NUUkxfVFlQRV9IMjY0X0RFQ09ERV9QQVJB TVMgOmM6dHlwZTpgdjRsMl9jdHJsX3R5cGVgCj4gIAo+ICAjIFY0TDIgY2FwYWJpbGl0eSBkZWZp bmVzCj4gIHJlcGxhY2UgZGVmaW5lIFY0TDJfQ0FQX1ZJREVPX0NBUFRVUkUgZGV2aWNlLWNhcGFi aWxpdGllcwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3Y0bDItY29yZS92NGwyLWN0cmxz LmMgYi9kcml2ZXJzL21lZGlhL3Y0bDItY29yZS92NGwyLWN0cmxzLmMKPiBpbmRleCBiMWFlMmU1 NTVjNjguLjQ2YWVjOGMzYWNkZSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL21lZGlhL3Y0bDItY29y ZS92NGwyLWN0cmxzLmMKPiArKysgYi9kcml2ZXJzL21lZGlhL3Y0bDItY29yZS92NGwyLWN0cmxz LmMKPiBAQCAtODI4LDYgKzgyOCwxMSBAQCBjb25zdCBjaGFyICp2NGwyX2N0cmxfZ2V0X25hbWUo dTMyIGlkKQo+ICAJY2FzZSBWNEwyX0NJRF9NUEVHX1ZJREVPX0gyNjRfQ09OU1RSQUlORURfSU5U UkFfUFJFRElDVElPTjoKPiAgCQkJCQkJCQlyZXR1cm4gIkgyNjQgQ29uc3RyYWluZWQgSW50cmEg UHJlZCI7Cj4gIAljYXNlIFY0TDJfQ0lEX01QRUdfVklERU9fSDI2NF9DSFJPTUFfUVBfSU5ERVhf T0ZGU0VUOglyZXR1cm4gIkgyNjQgQ2hyb21hIFFQIEluZGV4IE9mZnNldCI7Cj4gKwljYXNlIFY0 TDJfQ0lEX01QRUdfVklERU9fSDI2NF9TUFM6CQkJcmV0dXJuICJIMjY0IFNlcXVlbmNlIFBhcmFt ZXRlciBTZXQiOwo+ICsJY2FzZSBWNEwyX0NJRF9NUEVHX1ZJREVPX0gyNjRfUFBTOgkJCXJldHVy biAiSDI2NCBQaWN0dXJlIFBhcmFtZXRlciBTZXQiOwo+ICsJY2FzZSBWNEwyX0NJRF9NUEVHX1ZJ REVPX0gyNjRfU0NBTElOR19NQVRSSVg6CQlyZXR1cm4gIkgyNjQgU2NhbGluZyBNYXRyaXgiOwo+ ICsJY2FzZSBWNEwyX0NJRF9NUEVHX1ZJREVPX0gyNjRfU0xJQ0VfUEFSQU1TOgkJcmV0dXJuICJI MjY0IFNsaWNlIFBhcmFtZXRlcnMiOwo+ICsJY2FzZSBWNEwyX0NJRF9NUEVHX1ZJREVPX0gyNjRf REVDT0RFX1BBUkFNUzoJCXJldHVybiAiSDI2NCBEZWNvZGUgUGFyYW1ldGVycyI7Cj4gIAljYXNl IFY0TDJfQ0lEX01QRUdfVklERU9fTVBFRzRfSV9GUkFNRV9RUDoJCXJldHVybiAiTVBFRzQgSS1G cmFtZSBRUCBWYWx1ZSI7Cj4gIAljYXNlIFY0TDJfQ0lEX01QRUdfVklERU9fTVBFRzRfUF9GUkFN RV9RUDoJCXJldHVybiAiTVBFRzQgUC1GcmFtZSBRUCBWYWx1ZSI7Cj4gIAljYXNlIFY0TDJfQ0lE X01QRUdfVklERU9fTVBFRzRfQl9GUkFNRV9RUDoJCXJldHVybiAiTVBFRzQgQi1GcmFtZSBRUCBW YWx1ZSI7Cj4gQEAgLTEzMDksNiArMTMxNCwyMSBAQCB2b2lkIHY0bDJfY3RybF9maWxsKHUzMiBp ZCwgY29uc3QgY2hhciAqKm5hbWUsIGVudW0gdjRsMl9jdHJsX3R5cGUgKnR5cGUsCj4gIAljYXNl IFY0TDJfQ0lEX01QRUdfVklERU9fRldIVF9QQVJBTVM6Cj4gIAkJKnR5cGUgPSBWNEwyX0NUUkxf VFlQRV9GV0hUX1BBUkFNUzsKPiAgCQlicmVhazsKPiArCWNhc2UgVjRMMl9DSURfTVBFR19WSURF T19IMjY0X1NQUzoKPiArCQkqdHlwZSA9IFY0TDJfQ1RSTF9UWVBFX0gyNjRfU1BTOwo+ICsJCWJy ZWFrOwo+ICsJY2FzZSBWNEwyX0NJRF9NUEVHX1ZJREVPX0gyNjRfUFBTOgo+ICsJCSp0eXBlID0g VjRMMl9DVFJMX1RZUEVfSDI2NF9QUFM7Cj4gKwkJYnJlYWs7Cj4gKwljYXNlIFY0TDJfQ0lEX01Q RUdfVklERU9fSDI2NF9TQ0FMSU5HX01BVFJJWDoKPiArCQkqdHlwZSA9IFY0TDJfQ1RSTF9UWVBF X0gyNjRfU0NBTElOR19NQVRSSVg7Cj4gKwkJYnJlYWs7Cj4gKwljYXNlIFY0TDJfQ0lEX01QRUdf VklERU9fSDI2NF9TTElDRV9QQVJBTVM6Cj4gKwkJKnR5cGUgPSBWNEwyX0NUUkxfVFlQRV9IMjY0 X1NMSUNFX1BBUkFNUzsKPiArCQlicmVhazsKPiArCWNhc2UgVjRMMl9DSURfTVBFR19WSURFT19I MjY0X0RFQ09ERV9QQVJBTVM6Cj4gKwkJKnR5cGUgPSBWNEwyX0NUUkxfVFlQRV9IMjY0X0RFQ09E RV9QQVJBTVM7Cj4gKwkJYnJlYWs7Cj4gIAlkZWZhdWx0Ogo+ICAJCSp0eXBlID0gVjRMMl9DVFJM X1RZUEVfSU5URUdFUjsKPiAgCQlicmVhazsKPiBAQCAtMTY3OCw2ICsxNjk4LDEzIEBAIHN0YXRp YyBpbnQgc3RkX3ZhbGlkYXRlKGNvbnN0IHN0cnVjdCB2NGwyX2N0cmwgKmN0cmwsIHUzMiBpZHgs Cj4gIAljYXNlIFY0TDJfQ1RSTF9UWVBFX0ZXSFRfUEFSQU1TOgo+ICAJCXJldHVybiAwOwo+ICAK PiArCWNhc2UgVjRMMl9DVFJMX1RZUEVfSDI2NF9TUFM6Cj4gKwljYXNlIFY0TDJfQ1RSTF9UWVBF X0gyNjRfUFBTOgo+ICsJY2FzZSBWNEwyX0NUUkxfVFlQRV9IMjY0X1NDQUxJTkdfTUFUUklYOgo+ ICsJY2FzZSBWNEwyX0NUUkxfVFlQRV9IMjY0X1NMSUNFX1BBUkFNUzoKPiArCWNhc2UgVjRMMl9D VFJMX1RZUEVfSDI2NF9ERUNPREVfUEFSQU1TOgo+ICsJCXJldHVybiAwOwo+ICsKPiAgCWRlZmF1 bHQ6Cj4gIAkJcmV0dXJuIC1FSU5WQUw7Cj4gIAl9Cj4gQEAgLTIyNjEsNiArMjI4OCwyMSBAQCBz dGF0aWMgc3RydWN0IHY0bDJfY3RybCAqdjRsMl9jdHJsX25ldyhzdHJ1Y3QgdjRsMl9jdHJsX2hh bmRsZXIgKmhkbCwKPiAgCWNhc2UgVjRMMl9DVFJMX1RZUEVfRldIVF9QQVJBTVM6Cj4gIAkJZWxl bV9zaXplID0gc2l6ZW9mKHN0cnVjdCB2NGwyX2N0cmxfZndodF9wYXJhbXMpOwo+ICAJCWJyZWFr Owo+ICsJY2FzZSBWNEwyX0NUUkxfVFlQRV9IMjY0X1NQUzoKPiArCQllbGVtX3NpemUgPSBzaXpl b2Yoc3RydWN0IHY0bDJfY3RybF9oMjY0X3Nwcyk7Cj4gKwkJYnJlYWs7Cj4gKwljYXNlIFY0TDJf Q1RSTF9UWVBFX0gyNjRfUFBTOgo+ICsJCWVsZW1fc2l6ZSA9IHNpemVvZihzdHJ1Y3QgdjRsMl9j dHJsX2gyNjRfcHBzKTsKPiArCQlicmVhazsKPiArCWNhc2UgVjRMMl9DVFJMX1RZUEVfSDI2NF9T Q0FMSU5HX01BVFJJWDoKPiArCQllbGVtX3NpemUgPSBzaXplb2Yoc3RydWN0IHY0bDJfY3RybF9o MjY0X3NjYWxpbmdfbWF0cml4KTsKPiArCQlicmVhazsKPiArCWNhc2UgVjRMMl9DVFJMX1RZUEVf SDI2NF9TTElDRV9QQVJBTVM6Cj4gKwkJZWxlbV9zaXplID0gc2l6ZW9mKHN0cnVjdCB2NGwyX2N0 cmxfaDI2NF9zbGljZV9wYXJhbXMpOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSBWNEwyX0NUUkxfVFlQ RV9IMjY0X0RFQ09ERV9QQVJBTVM6Cj4gKwkJZWxlbV9zaXplID0gc2l6ZW9mKHN0cnVjdCB2NGwy X2N0cmxfaDI2NF9kZWNvZGVfcGFyYW1zKTsKPiArCQlicmVhazsKPiAgCWRlZmF1bHQ6Cj4gIAkJ aWYgKHR5cGUgPCBWNEwyX0NUUkxfQ09NUE9VTkRfVFlQRVMpCj4gIAkJCWVsZW1fc2l6ZSA9IHNp emVvZihzMzIpOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3Y0bDItY29yZS92NGwyLWlv Y3RsLmMgYi9kcml2ZXJzL21lZGlhL3Y0bDItY29yZS92NGwyLWlvY3RsLmMKPiBpbmRleCBhYzg3 YzNlMzcyODAuLmY2ZTEyNTQwNjRkMiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL21lZGlhL3Y0bDIt Y29yZS92NGwyLWlvY3RsLmMKPiArKysgYi9kcml2ZXJzL21lZGlhL3Y0bDItY29yZS92NGwyLWlv Y3RsLmMKPiBAQCAtMTMyNSw2ICsxMzI1LDcgQEAgc3RhdGljIHZvaWQgdjRsX2ZpbGxfZm10ZGVz YyhzdHJ1Y3QgdjRsMl9mbXRkZXNjICpmbXQpCj4gIAkJY2FzZSBWNEwyX1BJWF9GTVRfSDI2NDoJ CWRlc2NyID0gIkguMjY0IjsgYnJlYWs7Cj4gIAkJY2FzZSBWNEwyX1BJWF9GTVRfSDI2NF9OT19T QzoJZGVzY3IgPSAiSC4yNjQgKE5vIFN0YXJ0IENvZGVzKSI7IGJyZWFrOwo+ICAJCWNhc2UgVjRM Ml9QSVhfRk1UX0gyNjRfTVZDOglkZXNjciA9ICJILjI2NCBNVkMiOyBicmVhazsKPiArCQljYXNl IFY0TDJfUElYX0ZNVF9IMjY0X1NMSUNFX1JBVzoJZGVzY3IgPSAiSC4yNjQgUGFyc2VkIFNsaWNl IERhdGEiOyBicmVhazsKPiAgCQljYXNlIFY0TDJfUElYX0ZNVF9IMjYzOgkJZGVzY3IgPSAiSC4y NjMiOyBicmVhazsKPiAgCQljYXNlIFY0TDJfUElYX0ZNVF9NUEVHMToJZGVzY3IgPSAiTVBFRy0x IEVTIjsgYnJlYWs7Cj4gIAkJY2FzZSBWNEwyX1BJWF9GTVRfTVBFRzI6CWRlc2NyID0gIk1QRUct MiBFUyI7IGJyZWFrOwo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL21lZGlhL2gyNjQtY3RybHMuaCBi L2luY2x1ZGUvbWVkaWEvaDI2NC1jdHJscy5oCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRl eCAwMDAwMDAwMDAwMDAuLmUyZjgzYjNjZGJlZgo+IC0tLSAvZGV2L251bGwKPiArKysgYi9pbmNs dWRlL21lZGlhL2gyNjQtY3RybHMuaAo+IEBAIC0wLDAgKzEsMTkyIEBACj4gKy8qIFNQRFgtTGlj ZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wICovCj4gKy8qCj4gKyAqIFRoZXNlIGFyZSB0aGUgSC4y NjQgc3RhdGUgY29udHJvbHMgZm9yIHVzZSB3aXRoIHN0YXRlbGVzcyBILjI2NAo+ICsgKiBjb2Rl YyBkcml2ZXJzLgo+ICsgKgo+ICsgKiBJdCB0dXJucyBvdXQgdGhhdCB0aGVzZSBzdHJ1Y3RzIGFy ZSBub3Qgc3RhYmxlIHlldCBhbmQgd2lsbCB1bmRlcmdvCj4gKyAqIG1vcmUgY2hhbmdlcy4gU28g a2VlcCB0aGVtIHByaXZhdGUgdW50aWwgdGhleSBhcmUgc3RhYmxlIGFuZCByZWFkeSB0bwo+ICsg KiBiZWNvbWUgcGFydCBvZiB0aGUgb2ZmaWNpYWwgcHVibGljIEFQSS4KPiArICovCj4gKwo+ICsj aWZuZGVmIF9IMjY0X0NUUkxTX0hfCj4gKyNkZWZpbmUgX0gyNjRfQ1RSTFNfSF8KPiArCj4gKy8q Cj4gKyAqIFRoaXMgaXMgcHV0IGluc2FuZWx5IGhpZ2ggdG8gYXZvaWQgY29uZmxpY3Rpbmcgd2l0 aCBjb250cm9scyB0aGF0Cj4gKyAqIHdvdWxkIGJlIGFkZGVkIGR1cmluZyB0aGUgcGhhc2Ugd2hl cmUgdGhvc2UgY29udHJvbHMgYXJlIG5vdAo+ICsgKiBzdGFibGUuIEl0IHNob3VsZCBiZSBmaXhl ZCBldmVudHVhbGx5Lgo+ICsgKi8KPiArI2RlZmluZSBWNEwyX0NJRF9NUEVHX1ZJREVPX0gyNjRf U1BTCQkoVjRMMl9DSURfTVBFR19CQVNFKzEwMDApCj4gKyNkZWZpbmUgVjRMMl9DSURfTVBFR19W SURFT19IMjY0X1BQUwkJKFY0TDJfQ0lEX01QRUdfQkFTRSsxMDAxKQo+ICsjZGVmaW5lIFY0TDJf Q0lEX01QRUdfVklERU9fSDI2NF9TQ0FMSU5HX01BVFJJWAkoVjRMMl9DSURfTVBFR19CQVNFKzEw MDIpCj4gKyNkZWZpbmUgVjRMMl9DSURfTVBFR19WSURFT19IMjY0X1NMSUNFX1BBUkFNUwkoVjRM Ml9DSURfTVBFR19CQVNFKzEwMDMpCj4gKyNkZWZpbmUgVjRMMl9DSURfTVBFR19WSURFT19IMjY0 X0RFQ09ERV9QQVJBTVMJKFY0TDJfQ0lEX01QRUdfQkFTRSsxMDA0KQo+ICsKPiArLyogZW51bSB2 NGwyX2N0cmxfdHlwZSB0eXBlIHZhbHVlcyAqLwo+ICsjZGVmaW5lIFY0TDJfQ1RSTF9UWVBFX0gy NjRfU1BTCQkJMHgwMTEwCj4gKyNkZWZpbmUgVjRMMl9DVFJMX1RZUEVfSDI2NF9QUFMJCQkweDAx MTEKPiArI2RlZmluZSBWNEwyX0NUUkxfVFlQRV9IMjY0X1NDQUxJTkdfTUFUUklYCTB4MDExMgo+ ICsjZGVmaW5lIFY0TDJfQ1RSTF9UWVBFX0gyNjRfU0xJQ0VfUEFSQU1TCTB4MDExMwo+ICsjZGVm aW5lIFY0TDJfQ1RSTF9UWVBFX0gyNjRfREVDT0RFX1BBUkFNUwkweDAxMTQKPiArCj4gKyNkZWZp bmUgVjRMMl9IMjY0X1NQU19DT05TVFJBSU5UX1NFVDBfRkxBRwkJCTB4MDEKPiArI2RlZmluZSBW NEwyX0gyNjRfU1BTX0NPTlNUUkFJTlRfU0VUMV9GTEFHCQkJMHgwMgo+ICsjZGVmaW5lIFY0TDJf SDI2NF9TUFNfQ09OU1RSQUlOVF9TRVQyX0ZMQUcJCQkweDA0Cj4gKyNkZWZpbmUgVjRMMl9IMjY0 X1NQU19DT05TVFJBSU5UX1NFVDNfRkxBRwkJCTB4MDgKPiArI2RlZmluZSBWNEwyX0gyNjRfU1BT X0NPTlNUUkFJTlRfU0VUNF9GTEFHCQkJMHgxMAo+ICsjZGVmaW5lIFY0TDJfSDI2NF9TUFNfQ09O U1RSQUlOVF9TRVQ1X0ZMQUcJCQkweDIwCj4gKwo+ICsjZGVmaW5lIFY0TDJfSDI2NF9TUFNfRkxB R19TRVBBUkFURV9DT0xPVVJfUExBTkUJCTB4MDEKPiArI2RlZmluZSBWNEwyX0gyNjRfU1BTX0ZM QUdfUVBQUklNRV9ZX1pFUk9fVFJBTlNGT1JNX0JZUEFTUwkweDAyCj4gKyNkZWZpbmUgVjRMMl9I MjY0X1NQU19GTEFHX0RFTFRBX1BJQ19PUkRFUl9BTFdBWVNfWkVSTwkJMHgwNAo+ICsjZGVmaW5l IFY0TDJfSDI2NF9TUFNfRkxBR19HQVBTX0lOX0ZSQU1FX05VTV9WQUxVRV9BTExPV0VECTB4MDgK PiArI2RlZmluZSBWNEwyX0gyNjRfU1BTX0ZMQUdfRlJBTUVfTUJTX09OTFkJCQkweDEwCj4gKyNk ZWZpbmUgVjRMMl9IMjY0X1NQU19GTEFHX01CX0FEQVBUSVZFX0ZSQU1FX0ZJRUxECQkweDIwCj4g KyNkZWZpbmUgVjRMMl9IMjY0X1NQU19GTEFHX0RJUkVDVF84WDhfSU5GRVJFTkNFCQkJMHg0MAo+ ICsKPiArc3RydWN0IHY0bDJfY3RybF9oMjY0X3NwcyB7Cj4gKwlfX3U4IHByb2ZpbGVfaWRjOwo+ ICsJX191OCBjb25zdHJhaW50X3NldF9mbGFnczsKPiArCV9fdTggbGV2ZWxfaWRjOwo+ICsJX191 OCBzZXFfcGFyYW1ldGVyX3NldF9pZDsKPiArCV9fdTggY2hyb21hX2Zvcm1hdF9pZGM7Cj4gKwlf X3U4IGJpdF9kZXB0aF9sdW1hX21pbnVzODsKPiArCV9fdTggYml0X2RlcHRoX2Nocm9tYV9taW51 czg7Cj4gKwlfX3U4IGxvZzJfbWF4X2ZyYW1lX251bV9taW51czQ7Cj4gKwlfX3U4IHBpY19vcmRl cl9jbnRfdHlwZTsKPiArCV9fdTggbG9nMl9tYXhfcGljX29yZGVyX2NudF9sc2JfbWludXM0Owo+ ICsJX191OCBtYXhfbnVtX3JlZl9mcmFtZXM7Cj4gKwlfX3U4IG51bV9yZWZfZnJhbWVzX2luX3Bp Y19vcmRlcl9jbnRfY3ljbGU7Cj4gKwlfX3MzMiBvZmZzZXRfZm9yX3JlZl9mcmFtZVsyNTVdOwo+ ICsJX19zMzIgb2Zmc2V0X2Zvcl9ub25fcmVmX3BpYzsKPiArCV9fczMyIG9mZnNldF9mb3JfdG9w X3RvX2JvdHRvbV9maWVsZDsKPiArCV9fdTE2IHBpY193aWR0aF9pbl9tYnNfbWludXMxOwo+ICsJ X191MTYgcGljX2hlaWdodF9pbl9tYXBfdW5pdHNfbWludXMxOwo+ICsJX191MzIgZmxhZ3M7Cj4g K307Cj4gKwo+ICsjZGVmaW5lIFY0TDJfSDI2NF9QUFNfRkxBR19FTlRST1BZX0NPRElOR19NT0RF CQkJCTB4MDAwMQo+ICsjZGVmaW5lIFY0TDJfSDI2NF9QUFNfRkxBR19CT1RUT01fRklFTERfUElD X09SREVSX0lOX0ZSQU1FX1BSRVNFTlQJMHgwMDAyCj4gKyNkZWZpbmUgVjRMMl9IMjY0X1BQU19G TEFHX1dFSUdIVEVEX1BSRUQJCQkJMHgwMDA0Cj4gKyNkZWZpbmUgVjRMMl9IMjY0X1BQU19GTEFH X0RFQkxPQ0tJTkdfRklMVEVSX0NPTlRST0xfUFJFU0VOVAkJMHgwMDA4Cj4gKyNkZWZpbmUgVjRM Ml9IMjY0X1BQU19GTEFHX0NPTlNUUkFJTkVEX0lOVFJBX1BSRUQJCQkweDAwMTAKPiArI2RlZmlu ZSBWNEwyX0gyNjRfUFBTX0ZMQUdfUkVEVU5EQU5UX1BJQ19DTlRfUFJFU0VOVAkJCTB4MDAyMAo+ ICsjZGVmaW5lIFY0TDJfSDI2NF9QUFNfRkxBR19UUkFOU0ZPUk1fOFg4X01PREUJCQkJMHgwMDQw Cj4gKyNkZWZpbmUgVjRMMl9IMjY0X1BQU19GTEFHX1BJQ19TQ0FMSU5HX01BVFJJWF9QUkVTRU5U CQkJMHgwMDgwCj4gKwo+ICtzdHJ1Y3QgdjRsMl9jdHJsX2gyNjRfcHBzIHsKPiArCV9fdTggcGlj X3BhcmFtZXRlcl9zZXRfaWQ7Cj4gKwlfX3U4IHNlcV9wYXJhbWV0ZXJfc2V0X2lkOwo+ICsJX191 OCBudW1fc2xpY2VfZ3JvdXBzX21pbnVzMTsKPiArCV9fdTggbnVtX3JlZl9pZHhfbDBfZGVmYXVs dF9hY3RpdmVfbWludXMxOwo+ICsJX191OCBudW1fcmVmX2lkeF9sMV9kZWZhdWx0X2FjdGl2ZV9t aW51czE7Cj4gKwlfX3U4IHdlaWdodGVkX2JpcHJlZF9pZGM7Cj4gKwlfX3M4IHBpY19pbml0X3Fw X21pbnVzMjY7Cj4gKwlfX3M4IHBpY19pbml0X3FzX21pbnVzMjY7Cj4gKwlfX3M4IGNocm9tYV9x cF9pbmRleF9vZmZzZXQ7Cj4gKwlfX3M4IHNlY29uZF9jaHJvbWFfcXBfaW5kZXhfb2Zmc2V0Owo+ ICsJX191MTYgZmxhZ3M7Cj4gK307Cj4gKwo+ICtzdHJ1Y3QgdjRsMl9jdHJsX2gyNjRfc2NhbGlu Z19tYXRyaXggewo+ICsJX191OCBzY2FsaW5nX2xpc3RfNHg0WzZdWzE2XTsKPiArCV9fdTggc2Nh bGluZ19saXN0Xzh4OFs2XVs2NF07Cj4gK307Cj4gKwo+ICtzdHJ1Y3QgdjRsMl9oMjY0X3dlaWdo dF9mYWN0b3JzIHsKPiArCV9fczE2IGx1bWFfd2VpZ2h0WzMyXTsKPiArCV9fczE2IGx1bWFfb2Zm c2V0WzMyXTsKPiArCV9fczE2IGNocm9tYV93ZWlnaHRbMzJdWzJdOwo+ICsJX19zMTYgY2hyb21h X29mZnNldFszMl1bMl07Cj4gK307Cj4gKwo+ICtzdHJ1Y3QgdjRsMl9oMjY0X3ByZWRfd2VpZ2h0 X3RhYmxlIHsKPiArCV9fdTE2IGx1bWFfbG9nMl93ZWlnaHRfZGVub207Cj4gKwlfX3UxNiBjaHJv bWFfbG9nMl93ZWlnaHRfZGVub207Cj4gKwlzdHJ1Y3QgdjRsMl9oMjY0X3dlaWdodF9mYWN0b3Jz IHdlaWdodF9mYWN0b3JzWzJdOwo+ICt9Owo+ICsKPiArI2RlZmluZSBWNEwyX0gyNjRfU0xJQ0Vf VFlQRV9QCQkJCTAKPiArI2RlZmluZSBWNEwyX0gyNjRfU0xJQ0VfVFlQRV9CCQkJCTEKPiArI2Rl ZmluZSBWNEwyX0gyNjRfU0xJQ0VfVFlQRV9JCQkJCTIKPiArI2RlZmluZSBWNEwyX0gyNjRfU0xJ Q0VfVFlQRV9TUAkJCQkzCj4gKyNkZWZpbmUgVjRMMl9IMjY0X1NMSUNFX1RZUEVfU0kJCQkJNAo+ ICsKPiArI2RlZmluZSBWNEwyX0gyNjRfU0xJQ0VfRkxBR19GSUVMRF9QSUMJCQkweDAxCj4gKyNk ZWZpbmUgVjRMMl9IMjY0X1NMSUNFX0ZMQUdfQk9UVE9NX0ZJRUxECQkweDAyCj4gKyNkZWZpbmUg VjRMMl9IMjY0X1NMSUNFX0ZMQUdfRElSRUNUX1NQQVRJQUxfTVZfUFJFRAkweDA0Cj4gKyNkZWZp bmUgVjRMMl9IMjY0X1NMSUNFX0ZMQUdfU1BfRk9SX1NXSVRDSAkJMHgwOAo+ICsKPiArc3RydWN0 IHY0bDJfY3RybF9oMjY0X3NsaWNlX3BhcmFtcyB7Cj4gKwkvKiBTaXplIGluIGJ5dGVzLCBpbmNs dWRpbmcgaGVhZGVyICovCj4gKwlfX3UzMiBzaXplOwo+ICsJLyogT2Zmc2V0IGluIGJpdHMgdG8g c2xpY2VfZGF0YSgpIGZyb20gdGhlIGJlZ2lubmluZyBvZiB0aGlzIHNsaWNlLiAqLwo+ICsJX191 MzIgaGVhZGVyX2JpdF9zaXplOwo+ICsKPiArCV9fdTE2IGZpcnN0X21iX2luX3NsaWNlOwo+ICsJ X191OCBzbGljZV90eXBlOwo+ICsJX191OCBwaWNfcGFyYW1ldGVyX3NldF9pZDsKPiArCV9fdTgg Y29sb3VyX3BsYW5lX2lkOwo+ICsJX191OCByZWR1bmRhbnRfcGljX2NudDsKPiArCV9fdTE2IGZy YW1lX251bTsKPiArCV9fdTE2IGlkcl9waWNfaWQ7Cj4gKwlfX3UxNiBwaWNfb3JkZXJfY250X2xz YjsKPiArCV9fczMyIGRlbHRhX3BpY19vcmRlcl9jbnRfYm90dG9tOwo+ICsJX19zMzIgZGVsdGFf cGljX29yZGVyX2NudDA7Cj4gKwlfX3MzMiBkZWx0YV9waWNfb3JkZXJfY250MTsKPiArCj4gKwlz dHJ1Y3QgdjRsMl9oMjY0X3ByZWRfd2VpZ2h0X3RhYmxlIHByZWRfd2VpZ2h0X3RhYmxlOwo+ICsJ LyogU2l6ZSBpbiBiaXRzIG9mIGRlY19yZWZfcGljX21hcmtpbmcoKSBzeW50YXggZWxlbWVudC4g Ki8KPiArCV9fdTMyIGRlY19yZWZfcGljX21hcmtpbmdfYml0X3NpemU7Cj4gKwkvKiBTaXplIGlu IGJpdHMgb2YgcGljIG9yZGVyIGNvdW50IHN5bnRheC4gKi8KPiArCV9fdTMyIHBpY19vcmRlcl9j bnRfYml0X3NpemU7Cj4gKwo+ICsJX191OCBjYWJhY19pbml0X2lkYzsKPiArCV9fczggc2xpY2Vf cXBfZGVsdGE7Cj4gKwlfX3M4IHNsaWNlX3FzX2RlbHRhOwo+ICsJX191OCBkaXNhYmxlX2RlYmxv Y2tpbmdfZmlsdGVyX2lkYzsKPiArCV9fczggc2xpY2VfYWxwaGFfYzBfb2Zmc2V0X2RpdjI7Cj4g KwlfX3M4IHNsaWNlX2JldGFfb2Zmc2V0X2RpdjI7Cj4gKwlfX3U4IG51bV9yZWZfaWR4X2wwX2Fj dGl2ZV9taW51czE7Cj4gKwlfX3U4IG51bV9yZWZfaWR4X2wxX2FjdGl2ZV9taW51czE7Cj4gKwlf X3UzMiBzbGljZV9ncm91cF9jaGFuZ2VfY3ljbGU7Cj4gKwo+ICsJLyoKPiArCSAqIEVudHJpZXMg b24gZWFjaCBsaXN0IGFyZSBpbmRpY2VzIGludG8KPiArCSAqIHY0bDJfY3RybF9oMjY0X2RlY29k ZV9wYXJhbXMuZHBiW10uCj4gKwkgKi8KPiArCV9fdTggcmVmX3BpY19saXN0MFszMl07Cj4gKwlf X3U4IHJlZl9waWNfbGlzdDFbMzJdOwo+ICsKPiArCV9fdTMyIGZsYWdzOwo+ICt9Owo+ICsKPiAr I2RlZmluZSBWNEwyX0gyNjRfRFBCX0VOVFJZX0ZMQUdfVkFMSUQJCTB4MDEKPiArI2RlZmluZSBW NEwyX0gyNjRfRFBCX0VOVFJZX0ZMQUdfQUNUSVZFCQkweDAyCj4gKyNkZWZpbmUgVjRMMl9IMjY0 X0RQQl9FTlRSWV9GTEFHX0xPTkdfVEVSTQkweDA0Cj4gKwo+ICtzdHJ1Y3QgdjRsMl9oMjY0X2Rw Yl9lbnRyeSB7Cj4gKwlfX3U2NCByZWZlcmVuY2VfdHM7Cj4gKwlfX3UxNiBmcmFtZV9udW07Cj4g KwlfX3UxNiBwaWNfbnVtOwo+ICsJLyogTm90ZSB0aGF0IGZpZWxkIGlzIGluZGljYXRlZCBieSB2 NGwyX2J1ZmZlci5maWVsZCAqLwo+ICsJX19zMzIgdG9wX2ZpZWxkX29yZGVyX2NudDsKPiArCV9f czMyIGJvdHRvbV9maWVsZF9vcmRlcl9jbnQ7Cj4gKwlfX3UzMiBmbGFnczsgLyogVjRMMl9IMjY0 X0RQQl9FTlRSWV9GTEFHXyogKi8KPiArfTsKPiArCj4gKyNkZWZpbmUgVjRMMl9IMjY0X0RFQ09E RV9QQVJBTV9GTEFHX0lEUl9QSUMJMHgwMQo+ICsKPiArc3RydWN0IHY0bDJfY3RybF9oMjY0X2Rl Y29kZV9wYXJhbXMgewo+ICsJc3RydWN0IHY0bDJfaDI2NF9kcGJfZW50cnkgZHBiWzE2XTsKPiAr CV9fdTE2IG51bV9zbGljZXM7Cj4gKwlfX3UxNiBuYWxfcmVmX2lkYzsKPiArCV9fdTggcmVmX3Bp Y19saXN0X3AwWzMyXTsKPiArCV9fdTggcmVmX3BpY19saXN0X2IwWzMyXTsKPiArCV9fdTggcmVm X3BpY19saXN0X2IxWzMyXTsKPiArCV9fczMyIHRvcF9maWVsZF9vcmRlcl9jbnQ7Cj4gKwlfX3Mz MiBib3R0b21fZmllbGRfb3JkZXJfY250Owo+ICsJX191MzIgZmxhZ3M7IC8qIFY0TDJfSDI2NF9E RUNPREVfUEFSQU1fRkxBR18qICovCj4gK307Cj4gKwo+ICsjZW5kaWYKPiBkaWZmIC0tZ2l0IGEv aW5jbHVkZS9tZWRpYS92NGwyLWN0cmxzLmggYi9pbmNsdWRlL21lZGlhL3Y0bDItY3RybHMuaAo+ IGluZGV4IGJkNjIxY2VjNjVhNS4uZGNlNmYzM2ZkNzQ5IDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUv bWVkaWEvdjRsMi1jdHJscy5oCj4gKysrIGIvaW5jbHVkZS9tZWRpYS92NGwyLWN0cmxzLmgKPiBA QCAtMjMsMTEgKzIzLDEyIEBACj4gICNpbmNsdWRlIDxtZWRpYS9tZWRpYS1yZXF1ZXN0Lmg+Cj4g IAo+ICAvKgo+IC0gKiBJbmNsdWRlIHRoZSBtcGVnMiBhbmQgZndodCBzdGF0ZWxlc3MgY29kZWMg Y29tcG91bmQgY29udHJvbCBkZWZpbml0aW9ucy4KPiArICogSW5jbHVkZSB0aGUgc3RhdGVsZXNz IGNvZGVjIGNvbXBvdW5kIGNvbnRyb2wgZGVmaW5pdGlvbnMuCj4gICAqIFRoaXMgd2lsbCBtb3Zl IHRvIHRoZSBwdWJsaWMgaGVhZGVycyBvbmNlIHRoaXMgQVBJIGlzIGZ1bGx5IHN0YWJsZS4KPiAg ICovCj4gICNpbmNsdWRlIDxtZWRpYS9tcGVnMi1jdHJscy5oPgo+ICAjaW5jbHVkZSA8bWVkaWEv ZndodC1jdHJscy5oPgo+ICsjaW5jbHVkZSA8bWVkaWEvaDI2NC1jdHJscy5oPgo+ICAKPiAgLyog Zm9yd2FyZCByZWZlcmVuY2VzICovCj4gIHN0cnVjdCBmaWxlOwo+IEBAIC01MSw2ICs1MiwxMSBA QCBzdHJ1Y3QgcG9sbF90YWJsZV9zdHJ1Y3Q7Cj4gICAqIEBwX21wZWcyX3NsaWNlX3BhcmFtczoJ UG9pbnRlciB0byBhIE1QRUcyIHNsaWNlIHBhcmFtZXRlcnMgc3RydWN0dXJlLgo+ICAgKiBAcF9t cGVnMl9xdWFudGl6YXRpb246CVBvaW50ZXIgdG8gYSBNUEVHMiBxdWFudGl6YXRpb24gZGF0YSBz dHJ1Y3R1cmUuCj4gICAqIEBwX2Z3aHRfcGFyYW1zOgkJUG9pbnRlciB0byBhIEZXSFQgc3RhdGVs ZXNzIHBhcmFtZXRlcnMgc3RydWN0dXJlLgo+ICsgKiBAcF9oMjY0X3NwczoJCQlQb2ludGVyIHRv IGEgc3RydWN0IHY0bDJfY3RybF9oMjY0X3Nwcy4KPiArICogQHBfaDI2NF9wcHM6CQkJUG9pbnRl ciB0byBhIHN0cnVjdCB2NGwyX2N0cmxfaDI2NF9wcHMuCj4gKyAqIEBwX2gyNjRfc2NhbGluZ19t YXRyaXg6CVBvaW50ZXIgdG8gYSBzdHJ1Y3QgdjRsMl9jdHJsX2gyNjRfc2NhbGluZ19tYXRyaXgu Cj4gKyAqIEBwX2gyNjRfc2xpY2VfcGFyYW06CQlQb2ludGVyIHRvIGEgc3RydWN0IHY0bDJfY3Ry bF9oMjY0X3NsaWNlX3BhcmFtcy4KPiArICogQHBfaDI2NF9kZWNvZGVfcGFyYW06CVBvaW50ZXIg dG8gYSBzdHJ1Y3QgdjRsMl9jdHJsX2gyNjRfZGVjb2RlX3BhcmFtcy4KPiAgICogQHA6CQkJCVBv aW50ZXIgdG8gYSBjb21wb3VuZCB2YWx1ZS4KPiAgICovCj4gIHVuaW9uIHY0bDJfY3RybF9wdHIg ewo+IEBAIC02Myw2ICs2OSwxMSBAQCB1bmlvbiB2NGwyX2N0cmxfcHRyIHsKPiAgCXN0cnVjdCB2 NGwyX2N0cmxfbXBlZzJfc2xpY2VfcGFyYW1zICpwX21wZWcyX3NsaWNlX3BhcmFtczsKPiAgCXN0 cnVjdCB2NGwyX2N0cmxfbXBlZzJfcXVhbnRpemF0aW9uICpwX21wZWcyX3F1YW50aXphdGlvbjsK PiAgCXN0cnVjdCB2NGwyX2N0cmxfZndodF9wYXJhbXMgKnBfZndodF9wYXJhbXM7Cj4gKwlzdHJ1 Y3QgdjRsMl9jdHJsX2gyNjRfc3BzICpwX2gyNjRfc3BzOwo+ICsJc3RydWN0IHY0bDJfY3RybF9o MjY0X3BwcyAqcF9oMjY0X3BwczsKPiArCXN0cnVjdCB2NGwyX2N0cmxfaDI2NF9zY2FsaW5nX21h dHJpeCAqcF9oMjY0X3NjYWxpbmdfbWF0cml4Owo+ICsJc3RydWN0IHY0bDJfY3RybF9oMjY0X3Ns aWNlX3BhcmFtcyAqcF9oMjY0X3NsaWNlX3BhcmFtOwo+ICsJc3RydWN0IHY0bDJfY3RybF9oMjY0 X2RlY29kZV9wYXJhbXMgKnBfaDI2NF9kZWNvZGVfcGFyYW07Cj4gIAl2b2lkICpwOwo+ICB9Owo+ ICAKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS91YXBpL2xpbnV4L3ZpZGVvZGV2Mi5oIGIvaW5jbHVk ZS91YXBpL2xpbnV4L3ZpZGVvZGV2Mi5oCj4gaW5kZXggNDk2ZTY0NTM0NTBjLi44Mzg3MzJhY2Rl ZmMgMTAwNjQ0Cj4gLS0tIGEvaW5jbHVkZS91YXBpL2xpbnV4L3ZpZGVvZGV2Mi5oCj4gKysrIGIv aW5jbHVkZS91YXBpL2xpbnV4L3ZpZGVvZGV2Mi5oCj4gQEAgLTY1Nyw2ICs2NTcsNyBAQCBzdHJ1 Y3QgdjRsMl9waXhfZm9ybWF0IHsKPiAgI2RlZmluZSBWNEwyX1BJWF9GTVRfSDI2NCAgICAgdjRs Ml9mb3VyY2MoJ0gnLCAnMicsICc2JywgJzQnKSAvKiBIMjY0IHdpdGggc3RhcnQgY29kZXMgKi8K PiAgI2RlZmluZSBWNEwyX1BJWF9GTVRfSDI2NF9OT19TQyB2NGwyX2ZvdXJjYygnQScsICdWJywg J0MnLCAnMScpIC8qIEgyNjQgd2l0aG91dCBzdGFydCBjb2RlcyAqLwo+ICAjZGVmaW5lIFY0TDJf UElYX0ZNVF9IMjY0X01WQyB2NGwyX2ZvdXJjYygnTScsICcyJywgJzYnLCAnNCcpIC8qIEgyNjQg TVZDICovCj4gKyNkZWZpbmUgVjRMMl9QSVhfRk1UX0gyNjRfU0xJQ0VfUkFXIHY0bDJfZm91cmNj KCdTJywgJzInLCAnNicsICc0JykgLyogSDI2NCBwYXJzZWQgc2xpY2VzICovCj4gICNkZWZpbmUg VjRMMl9QSVhfRk1UX0gyNjMgICAgIHY0bDJfZm91cmNjKCdIJywgJzInLCAnNicsICczJykgLyog SDI2MyAgICAgICAgICAqLwo+ICAjZGVmaW5lIFY0TDJfUElYX0ZNVF9NUEVHMSAgICB2NGwyX2Zv dXJjYygnTScsICdQJywgJ0cnLCAnMScpIC8qIE1QRUctMSBFUyAgICAgKi8KPiAgI2RlZmluZSBW NEwyX1BJWF9GTVRfTVBFRzIgICAgdjRsMl9mb3VyY2MoJ00nLCAnUCcsICdHJywgJzInKSAvKiBN UEVHLTIgRVMgICAgICovCi0tIApQYXVsIEtvY2lhbGtvd3NraSwgQm9vdGxpbgpFbWJlZGRlZCBM aW51eCBhbmQga2VybmVsIGVuZ2luZWVyaW5nCmh0dHBzOi8vYm9vdGxpbi5jb20KCgpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVs IG1haWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDov L2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==