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=-9.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_GIT 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 256D9C3A5A1 for ; Thu, 22 Aug 2019 19:45:46 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id DC13D233FD for ; Thu, 22 Aug 2019 19:45:45 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2404248AbfHVTpo convert rfc822-to-8bit (ORCPT ); Thu, 22 Aug 2019 15:45:44 -0400 Received: from mailoutvs59.siol.net ([185.57.226.250]:56159 "EHLO mail.siol.net" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S2392134AbfHVTpZ (ORCPT ); Thu, 22 Aug 2019 15:45:25 -0400 Received: from localhost (localhost [127.0.0.1]) by mail.siol.net (Postfix) with ESMTP id 1854E5249F3; Thu, 22 Aug 2019 21:45:21 +0200 (CEST) X-Virus-Scanned: amavisd-new at psrvmta11.zcs-production.pri Received: from mail.siol.net ([127.0.0.1]) by localhost (psrvmta11.zcs-production.pri [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id daLeGRkLnMNS; Thu, 22 Aug 2019 21:45:19 +0200 (CEST) Received: from mail.siol.net (localhost [127.0.0.1]) by mail.siol.net (Postfix) with ESMTPS id 350845249EB; Thu, 22 Aug 2019 21:45:19 +0200 (CEST) Received: from localhost.localdomain (cpe-86-58-59-25.static.triera.net [86.58.59.25]) (Authenticated sender: 031275009) by mail.siol.net (Postfix) with ESMTPSA id B46455249F3; Thu, 22 Aug 2019 21:45:16 +0200 (CEST) From: Jernej Skrabec To: mchehab@kernel.org, hverkuil-cisco@xs4all.nl, paul.kocialkowski@bootlin.com, mripard@kernel.org Cc: pawel@osciak.com, m.szyprowski@samsung.com, kyungmin.park@samsung.com, tfiga@chromium.org, wens@csie.org, acourbot@chromium.org, gregkh@linuxfoundation.org, jernej.skrabec@siol.net, linux-media@vger.kernel.org, linux-kernel@vger.kernel.org, devel@driverdev.osuosl.org, linux-arm-kernel@lists.infradead.org, ezequiel@collabora.com, jonas@kwiboo.se Subject: [PATCH 4/8] media: docs-rst: Document memory-to-memory video encoder interface Date: Thu, 22 Aug 2019 21:44:56 +0200 Message-Id: <20190822194500.2071-5-jernej.skrabec@siol.net> X-Mailer: git-send-email 2.22.1 In-Reply-To: <20190822194500.2071-1-jernej.skrabec@siol.net> References: <20190822194500.2071-1-jernej.skrabec@siol.net> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8BIT Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Tomasz Figa Due to complexity of the video encoding process, the V4L2 drivers of stateful encoder hardware require specific sequences of V4L2 API calls to be followed. These include capability enumeration, initialization, encoding, encode parameters change, drain and reset. Specifics of the above have been discussed during Media Workshops at LinuxCon Europe 2012 in Barcelona and then later Embedded Linux Conference Europe 2014 in Düsseldorf. The de facto Codec API that originated at those events was later implemented by the drivers we already have merged in mainline, such as s5p-mfc or coda. The only thing missing was the real specification included as a part of Linux Media documentation. Fix it now and document the encoder part of the Codec API. Signed-off-by: Tomasz Figa Signed-off-by: Hans Verkuil Signed-off-by: Jernej Skrabec --- Documentation/media/uapi/v4l/dev-encoder.rst | 608 ++++++++++++++++++ Documentation/media/uapi/v4l/dev-mem2mem.rst | 1 + Documentation/media/uapi/v4l/pixfmt-v4l2.rst | 5 + Documentation/media/uapi/v4l/v4l2.rst | 2 + .../media/uapi/v4l/vidioc-encoder-cmd.rst | 51 +- 5 files changed, 647 insertions(+), 20 deletions(-) create mode 100644 Documentation/media/uapi/v4l/dev-encoder.rst diff --git a/Documentation/media/uapi/v4l/dev-encoder.rst b/Documentation/media/uapi/v4l/dev-encoder.rst new file mode 100644 index 000000000000..e9d29d6de67a --- /dev/null +++ b/Documentation/media/uapi/v4l/dev-encoder.rst @@ -0,0 +1,608 @@ +.. SPDX-License-Identifier: GPL-2.0 + +.. _encoder: + +************************************************* +Memory-to-Memory Stateful Video Encoder Interface +************************************************* + +A stateful video encoder takes raw video frames in display order and encodes +them into a bytestream. It generates complete chunks of the bytestream, including +all metadata, headers, etc. The resulting bytestream does not require any +further post-processing by the client. + +Performing software stream processing, header generation etc. in the driver +in order to support this interface is strongly discouraged. In case such +operations are needed, use of the Stateless Video Encoder Interface (in +development) is strongly advised. + +Conventions and Notations Used in This Document +=============================================== + +1. The general V4L2 API rules apply if not specified in this document + otherwise. + +2. The meaning of words "must", "may", "should", etc. is as per `RFC + 2119 `_. + +3. All steps not marked "optional" are required. + +4. :c:func:`VIDIOC_G_EXT_CTRLS` and :c:func:`VIDIOC_S_EXT_CTRLS` may be used + interchangeably with :c:func:`VIDIOC_G_CTRL` and :c:func:`VIDIOC_S_CTRL`, + unless specified otherwise. + +5. Single-planar API (see :ref:`planar-apis`) and applicable structures may be + used interchangeably with multi-planar API, unless specified otherwise, + depending on encoder capabilities and following the general V4L2 guidelines. + +6. i = [a..b]: sequence of integers from a to b, inclusive, i.e. i = + [0..2]: i = 0, 1, 2. + +7. Given an ``OUTPUT`` buffer A, then A’ represents a buffer on the ``CAPTURE`` + queue containing data that resulted from processing buffer A. + +Glossary +======== + +Refer to :ref:`decoder-glossary`. + +State Machine +============= + +.. kernel-render:: DOT + :alt: DOT digraph of encoder state machine + :caption: Encoder State Machine + + digraph encoder_state_machine { + node [shape = doublecircle, label="Encoding"] Encoding; + + node [shape = circle, label="Initialization"] Initialization; + node [shape = circle, label="Stopped"] Stopped; + node [shape = circle, label="Drain"] Drain; + node [shape = circle, label="Reset"] Reset; + + node [shape = point]; qi + qi -> Initialization [ label = "open()" ]; + + Initialization -> Encoding [ label = "Both queues streaming" ]; + + Encoding -> Drain [ label = "V4L2_ENC_CMD_STOP" ]; + Encoding -> Reset [ label = "VIDIOC_STREAMOFF(CAPTURE)" ]; + Encoding -> Stopped [ label = "VIDIOC_STREAMOFF(OUTPUT)" ]; + Encoding -> Encoding; + + Drain -> Stopped [ label = "All CAPTURE\nbuffers dequeued\nor\nVIDIOC_STREAMOFF(OUTPUT)" ]; + Drain -> Reset [ label = "VIDIOC_STREAMOFF(CAPTURE)" ]; + + Reset -> Encoding [ label = "VIDIOC_STREAMON(CAPTURE)" ]; + Reset -> Initialization [ label = "VIDIOC_REQBUFS(OUTPUT, 0)" ]; + + Stopped -> Encoding [ label = "V4L2_ENC_CMD_START\nor\nVIDIOC_STREAMON(OUTPUT)" ]; + Stopped -> Reset [ label = "VIDIOC_STREAMOFF(CAPTURE)" ]; + } + +Querying Capabilities +===================== + +1. To enumerate the set of coded formats supported by the encoder, the + client may call :c:func:`VIDIOC_ENUM_FMT` on ``CAPTURE``. + + * The full set of supported formats will be returned, regardless of the + format set on ``OUTPUT``. + +2. To enumerate the set of supported raw formats, the client may call + :c:func:`VIDIOC_ENUM_FMT` on ``OUTPUT``. + + * Only the formats supported for the format currently active on ``CAPTURE`` + will be returned. + + * In order to enumerate raw formats supported by a given coded format, + the client must first set that coded format on ``CAPTURE`` and then + enumerate the formats on ``OUTPUT``. + +3. The client may use :c:func:`VIDIOC_ENUM_FRAMESIZES` to detect supported + resolutions for a given format, passing desired pixel format in + :c:type:`v4l2_frmsizeenum` ``pixel_format``. + + * Values returned by :c:func:`VIDIOC_ENUM_FRAMESIZES` for a coded pixel + format will include all possible coded resolutions supported by the + encoder for given coded pixel format. + + * Values returned by :c:func:`VIDIOC_ENUM_FRAMESIZES` for a raw pixel format + will include all possible frame buffer resolutions supported by the + encoder for given raw pixel format and coded format currently set on + ``CAPTURE``. + +4. Supported profiles and levels for the coded format currently set on + ``CAPTURE``, if applicable, may be queried using their respective controls + via :c:func:`VIDIOC_QUERYCTRL`. + +5. Any additional encoder capabilities may be discovered by querying + their respective controls. + +Initialization +============== + +1. Set the coded format on the ``CAPTURE`` queue via :c:func:`VIDIOC_S_FMT` + + * **Required fields:** + + ``type`` + a ``V4L2_BUF_TYPE_*`` enum appropriate for ``CAPTURE``. + + ``pixelformat`` + the coded format to be produced. + + ``sizeimage`` + desired size of ``CAPTURE`` buffers; the encoder may adjust it to + match hardware requirements. + + ``width``, ``height`` + ignored (read-only). + + other fields + follow standard semantics. + + * **Return fields:** + + ``sizeimage`` + adjusted size of ``CAPTURE`` buffers. + + ``width``, ``height`` + the coded size selected by the encoder based on current state, e.g. + ``OUTPUT`` format, selection rectangles, etc. (read-only). + + .. important:: + + Changing the ``CAPTURE`` format may change the currently set ``OUTPUT`` + format. How the new ``OUTPUT`` format is determined is up to the encoder + and the client must ensure it matches its needs afterwards. + +2. **Optional.** Enumerate supported ``OUTPUT`` formats (raw formats for + source) for the selected coded format via :c:func:`VIDIOC_ENUM_FMT`. + + * **Required fields:** + + ``type`` + a ``V4L2_BUF_TYPE_*`` enum appropriate for ``OUTPUT``. + + other fields + follow standard semantics. + + * **Return fields:** + + ``pixelformat`` + raw format supported for the coded format currently selected on + the ``CAPTURE`` queue. + + other fields + follow standard semantics. + +3. Set the raw source format on the ``OUTPUT`` queue via + :c:func:`VIDIOC_S_FMT`. + + * **Required fields:** + + ``type`` + a ``V4L2_BUF_TYPE_*`` enum appropriate for ``OUTPUT``. + + ``pixelformat`` + raw format of the source. + + ``width``, ``height`` + source resolution. + + other fields + follow standard semantics. + + * **Return fields:** + + ``width``, ``height`` + may be adjusted to match encoder minimums, maximums and alignment + requirements, as required by the currently selected formats, as + reported by :c:func:`VIDIOC_ENUM_FRAMESIZES`. + + other fields + follow standard semantics. + + * Setting the ``OUTPUT`` format will reset the selection rectangles to their + default values, based on the new resolution, as described in the next + step. + +4. **Optional.** Set the visible resolution for the stream metadata via + :c:func:`VIDIOC_S_SELECTION` on the ``OUTPUT`` queue if it is desired + to be different than the full OUTPUT resolution. + + * **Required fields:** + + ``type`` + a ``V4L2_BUF_TYPE_*`` enum appropriate for ``OUTPUT``. + + ``target`` + set to ``V4L2_SEL_TGT_CROP``. + + ``r.left``, ``r.top``, ``r.width``, ``r.height`` + visible rectangle; this must fit within the `V4L2_SEL_TGT_CROP_BOUNDS` + rectangle and may be subject to adjustment to match codec and + hardware constraints. + + * **Return fields:** + + ``r.left``, ``r.top``, ``r.width``, ``r.height`` + visible rectangle adjusted by the encoder. + + * The following selection targets are supported on ``OUTPUT``: + + ``V4L2_SEL_TGT_CROP_BOUNDS`` + equal to the full source frame, matching the active ``OUTPUT`` + format. + + ``V4L2_SEL_TGT_CROP_DEFAULT`` + equal to ``V4L2_SEL_TGT_CROP_BOUNDS``. + + ``V4L2_SEL_TGT_CROP`` + rectangle within the source buffer to be encoded into the + ``CAPTURE`` stream; defaults to ``V4L2_SEL_TGT_CROP_DEFAULT``. + + .. note:: + + A common use case for this selection target is encoding a source + video with a resolution that is not a multiple of a macroblock, + e.g. the common 1920x1080 resolution may require the source + buffers to be aligned to 1920x1088 for codecs with 16x16 macroblock + size. To avoid encoding the padding, the client needs to explicitly + configure this selection target to 1920x1080. + + .. warning:: + + The encoder may adjust the crop/compose rectangles to the nearest + supported ones to meet codec and hardware requirements. The client needs + to check the adjusted rectangle returned by :c:func:`VIDIOC_S_SELECTION`. + +5. Allocate buffers for both ``OUTPUT`` and ``CAPTURE`` via + :c:func:`VIDIOC_REQBUFS`. This may be performed in any order. + + * **Required fields:** + + ``count`` + requested number of buffers to allocate; greater than zero. + + ``type`` + a ``V4L2_BUF_TYPE_*`` enum appropriate for ``OUTPUT`` or + ``CAPTURE``. + + other fields + follow standard semantics. + + * **Return fields:** + + ``count`` + actual number of buffers allocated. + + .. warning:: + + The actual number of allocated buffers may differ from the ``count`` + given. The client must check the updated value of ``count`` after the + call returns. + + .. note:: + + To allocate more than the minimum number of OUTPUT buffers (for pipeline + depth), the client may query the ``V4L2_CID_MIN_BUFFERS_FOR_OUTPUT`` + control to get the minimum number of buffers required, and pass the + obtained value plus the number of additional buffers needed in the + ``count`` field to :c:func:`VIDIOC_REQBUFS`. + + Alternatively, :c:func:`VIDIOC_CREATE_BUFS` can be used to have more + control over buffer allocation. + + * **Required fields:** + + ``count`` + requested number of buffers to allocate; greater than zero. + + ``type`` + a ``V4L2_BUF_TYPE_*`` enum appropriate for ``OUTPUT``. + + other fields + follow standard semantics. + + * **Return fields:** + + ``count`` + adjusted to the number of allocated buffers. + +6. Begin streaming on both ``OUTPUT`` and ``CAPTURE`` queues via + :c:func:`VIDIOC_STREAMON`. This may be performed in any order. The actual + encoding process starts when both queues start streaming. + +.. note:: + + If the client stops the ``CAPTURE`` queue during the encode process and then + restarts it again, the encoder will begin generating a stream independent + from the stream generated before the stop. The exact constraints depend + on the coded format, but may include the following implications: + + * encoded frames produced after the restart must not reference any + frames produced before the stop, e.g. no long term references for + H.264/HEVC, + + * any headers that must be included in a standalone stream must be + produced again, e.g. SPS and PPS for H.264/HEVC. + +Encoding +======== + +This state is reached after the `Initialization` sequence finishes +successfully. In this state, the client queues and dequeues buffers to both +queues via :c:func:`VIDIOC_QBUF` and :c:func:`VIDIOC_DQBUF`, following the +standard semantics. + +The content of encoded ``CAPTURE`` buffers depends on the active coded pixel +format and may be affected by codec-specific extended controls, as stated +in the documentation of each format. + +Both queues operate independently, following standard behavior of V4L2 buffer +queues and memory-to-memory devices. In addition, the order of encoded frames +dequeued from the ``CAPTURE`` queue may differ from the order of queuing raw +frames to the ``OUTPUT`` queue, due to properties of the selected coded format, +e.g. frame reordering. + +The client must not assume any direct relationship between ``CAPTURE`` and +``OUTPUT`` buffers and any specific timing of buffers becoming +available to dequeue. Specifically: + +* a buffer queued to ``OUTPUT`` may result in more than one buffer produced on + ``CAPTURE`` (if returning an encoded frame allowed the encoder to return a + frame that preceded it in display, but succeeded it in the decode order), + +* a buffer queued to ``OUTPUT`` may result in a buffer being produced on + ``CAPTURE`` later into encode process, and/or after processing further + ``OUTPUT`` buffers, or be returned out of order, e.g. if display + reordering is used, + +* buffers may become available on the ``CAPTURE`` queue without additional + buffers queued to ``OUTPUT`` (e.g. during drain or ``EOS``), because of the + ``OUTPUT`` buffers queued in the past whose decoding results are only + available at later time, due to specifics of the decoding process, + +* buffers queued to ``OUTPUT`` may not become available to dequeue instantly + after being encoded into a corresponding ``CAPTURE`` buffer, e.g. if the + encoder needs to use the frame as a reference for encoding further frames. + +.. note:: + + To allow matching encoded ``CAPTURE`` buffers with ``OUTPUT`` buffers they + originated from, the client can set the ``timestamp`` field of the + :c:type:`v4l2_buffer` struct when queuing an ``OUTPUT`` buffer. The + ``CAPTURE`` buffer(s), which resulted from encoding that ``OUTPUT`` buffer + will have their ``timestamp`` field set to the same value when dequeued. + + In addition to the straightforward case of one ``OUTPUT`` buffer producing + one ``CAPTURE`` buffer, the following cases are defined: + + * one ``OUTPUT`` buffer generates multiple ``CAPTURE`` buffers: the same + ``OUTPUT`` timestamp will be copied to multiple ``CAPTURE`` buffers, + + * the encoding order differs from the presentation order (i.e. the + ``CAPTURE`` buffers are out-of-order compared to the ``OUTPUT`` buffers): + ``CAPTURE`` timestamps will not retain the order of ``OUTPUT`` timestamps. + +.. note:: + + To let the client distinguish between frame types (keyframes, intermediate + frames; the exact list of types depends on the coded format), the + ``CAPTURE`` buffers will have corresponding flag bits set in their + :c:type:`v4l2_buffer` struct when dequeued. See the documentation of + :c:type:`v4l2_buffer` and each coded pixel format for exact list of flags + and their meanings. + +Should an encoding error occur, it will be reported to the client with the level +of details depending on the encoder capabilities. Specifically: + +* the CAPTURE buffer (if any) that contains the results of the failed encode + operation will be returned with the V4L2_BUF_FLAG_ERROR flag set, + +* if the encoder is able to precisely report the OUTPUT buffer(s) that triggered + the error, such buffer(s) will be returned with the V4L2_BUF_FLAG_ERROR flag + set. + +In case of a fatal failure that does not allow the encoding to continue, any +further operations on corresponding encoder file handle will return the -EIO +error code. The client may close the file handle and open a new one, or +alternatively reinitialize the instance by stopping streaming on both queues, +releasing all buffers and performing the Initialization sequence again. + +Encoding Parameter Changes +========================== + +The client is allowed to use :c:func:`VIDIOC_S_CTRL` to change encoder +parameters at any time. The availability of parameters is encoder-specific +and the client must query the encoder to find the set of available controls. + +The ability to change each parameter during encoding is encoder-specific, as +per the standard semantics of the V4L2 control interface. The client may +attempt to set a control during encoding and if the operation fails with the +-EBUSY error code, the ``CAPTURE`` queue needs to be stopped for the +configuration change to be allowed. To do this, it may follow the `Drain` +sequence to avoid losing the already queued/encoded frames. + +The timing of parameter updates is encoder-specific, as per the standard +semantics of the V4L2 control interface. If the client needs to apply the +parameters exactly at specific frame, using the Request API +(:ref:`media-request-api`) should be considered, if supported by the encoder. + +Drain +===== + +To ensure that all the queued ``OUTPUT`` buffers have been processed and the +related ``CAPTURE`` buffers are given to the client, the client must follow the +drain sequence described below. After the drain sequence ends, the client has +received all encoded frames for all ``OUTPUT`` buffers queued before the +sequence was started. + +1. Begin the drain sequence by issuing :c:func:`VIDIOC_ENCODER_CMD`. + + * **Required fields:** + + ``cmd`` + set to ``V4L2_ENC_CMD_STOP``. + + ``flags`` + set to 0. + + ``pts`` + set to 0. + + .. warning:: + + The sequence can be only initiated if both ``OUTPUT`` and ``CAPTURE`` + queues are streaming. For compatibility reasons, the call to + :c:func:`VIDIOC_ENCODER_CMD` will not fail even if any of the queues is + not streaming, but at the same time it will not initiate the `Drain` + sequence and so the steps described below would not be applicable. + +2. Any ``OUTPUT`` buffers queued by the client before the + :c:func:`VIDIOC_ENCODER_CMD` was issued will be processed and encoded as + normal. The client must continue to handle both queues independently, + similarly to normal encode operation. This includes: + + * queuing and dequeuing ``CAPTURE`` buffers, until a buffer marked with the + ``V4L2_BUF_FLAG_LAST`` flag is dequeued, + + .. warning:: + + The last buffer may be empty (with :c:type:`v4l2_buffer` + ``bytesused`` = 0) and in that case it must be ignored by the client, + as it does not contain an encoded frame. + + .. note:: + + Any attempt to dequeue more ``CAPTURE`` buffers beyond the buffer + marked with ``V4L2_BUF_FLAG_LAST`` will result in a -EPIPE error from + :c:func:`VIDIOC_DQBUF`. + + * dequeuing processed ``OUTPUT`` buffers, until all the buffers queued + before the ``V4L2_ENC_CMD_STOP`` command are dequeued, + + * dequeuing the ``V4L2_EVENT_EOS`` event, if the client subscribes to it. + + .. note:: + + For backwards compatibility, the encoder will signal a ``V4L2_EVENT_EOS`` + event when the last frame has been encoded and all frames are ready to be + dequeued. It is deprecated behavior and the client must not rely on it. + The ``V4L2_BUF_FLAG_LAST`` buffer flag should be used instead. + +3. Once all ``OUTPUT`` buffers queued before the ``V4L2_ENC_CMD_STOP`` call are + dequeued and the last ``CAPTURE`` buffer is dequeued, the encoder is stopped + and it will accept, but not process any newly queued ``OUTPUT`` buffers + until the client issues any of the following operations: + + * ``V4L2_ENC_CMD_START`` - the encoder will not be reset and will resume + operation normally, with all the state from before the drain, + + * a pair of :c:func:`VIDIOC_STREAMOFF` and :c:func:`VIDIOC_STREAMON` on the + ``CAPTURE`` queue - the encoder will be reset (see the `Reset` sequence) + and then resume encoding, + + * a pair of :c:func:`VIDIOC_STREAMOFF` and :c:func:`VIDIOC_STREAMON` on the + ``OUTPUT`` queue - the encoder will resume operation normally, however any + source frames queued to the ``OUTPUT`` queue between ``V4L2_ENC_CMD_STOP`` + and :c:func:`VIDIOC_STREAMOFF` will be discarded. + +.. note:: + + Once the drain sequence is initiated, the client needs to drive it to + completion, as described by the steps above, unless it aborts the process by + issuing :c:func:`VIDIOC_STREAMOFF` on any of the ``OUTPUT`` or ``CAPTURE`` + queues. The client is not allowed to issue ``V4L2_ENC_CMD_START`` or + ``V4L2_ENC_CMD_STOP`` again while the drain sequence is in progress and they + will fail with -EBUSY error code if attempted. + + For reference, handling of various corner cases is described below: + + * In case of no buffer in the ``OUTPUT`` queue at the time the + ``V4L2_ENC_CMD_STOP`` command was issued, the drain sequence completes + immediately and the encoder returns an empty ``CAPTURE`` buffer with the + ``V4L2_BUF_FLAG_LAST`` flag set. + + * In case of no buffer in the ``CAPTURE`` queue at the time the drain + sequence completes, the next time the client queues a ``CAPTURE`` buffer + it is returned at once as an empty buffer with the ``V4L2_BUF_FLAG_LAST`` + flag set. + + * If :c:func:`VIDIOC_STREAMOFF` is called on the ``CAPTURE`` queue in the + middle of the drain sequence, the drain sequence is canceled and all + ``CAPTURE`` buffers are implicitly returned to the client. + + * If :c:func:`VIDIOC_STREAMOFF` is called on the ``OUTPUT`` queue in the + middle of the drain sequence, the drain sequence completes immediately and + next ``CAPTURE`` buffer will be returned empty with the + ``V4L2_BUF_FLAG_LAST`` flag set. + + Although mandatory, the availability of encoder commands may be queried + using :c:func:`VIDIOC_TRY_ENCODER_CMD`. + +Reset +===== + +The client may want to request the encoder to reinitialize the encoding, so +that the following stream data becomes independent from the stream data +generated before. Depending on the coded format, that may imply that: + +* encoded frames produced after the restart must not reference any frames + produced before the stop, e.g. no long term references for H.264/HEVC, + +* any headers that must be included in a standalone stream must be produced + again, e.g. SPS and PPS for H.264/HEVC. + +This can be achieved by performing the reset sequence. + +1. Perform the `Drain` sequence to ensure all the in-flight encoding finishes + and respective buffers are dequeued. + +2. Stop streaming on the ``CAPTURE`` queue via :c:func:`VIDIOC_STREAMOFF`. This + will return all currently queued ``CAPTURE`` buffers to the client, without + valid frame data. + +3. Start streaming on the ``CAPTURE`` queue via :c:func:`VIDIOC_STREAMON` and + continue with regular encoding sequence. The encoded frames produced into + ``CAPTURE`` buffers from now on will contain a standalone stream that can be + decoded without the need for frames encoded before the reset sequence, + starting at the first ``OUTPUT`` buffer queued after issuing the + `V4L2_ENC_CMD_STOP` of the `Drain` sequence. + +This sequence may be also used to change encoding parameters for encoders +without the ability to change the parameters on the fly. + +Commit Points +============= + +Setting formats and allocating buffers triggers changes in the behavior of the +encoder. + +1. Setting the format on the ``CAPTURE`` queue may change the set of formats + supported/advertised on the ``OUTPUT`` queue. In particular, it also means + that the ``OUTPUT`` format may be reset and the client must not rely on the + previously set format being preserved. + +2. Enumerating formats on the ``OUTPUT`` queue always returns only formats + supported for the current ``CAPTURE`` format. + +3. Setting the format on the ``OUTPUT`` queue does not change the list of + formats available on the ``CAPTURE`` queue. An attempt to set the ``OUTPUT`` + format that is not supported for the currently selected ``CAPTURE`` format + will result in the encoder adjusting the requested ``OUTPUT`` format to a + supported one. + +4. Enumerating formats on the ``CAPTURE`` queue always returns the full set of + supported coded formats, irrespective of the current ``OUTPUT`` format. + +5. While buffers are allocated on any of the ``OUTPUT`` or ``CAPTURE`` queues, + the client must not change the format on the ``CAPTURE`` queue. Drivers will + return the -EBUSY error code for any such format change attempt. + +To summarize, setting formats and allocation must always start with the +``CAPTURE`` queue and the ``CAPTURE`` queue is the master that governs the +set of supported formats for the ``OUTPUT`` queue. diff --git a/Documentation/media/uapi/v4l/dev-mem2mem.rst b/Documentation/media/uapi/v4l/dev-mem2mem.rst index 70953958cee6..43f14ccb675e 100644 --- a/Documentation/media/uapi/v4l/dev-mem2mem.rst +++ b/Documentation/media/uapi/v4l/dev-mem2mem.rst @@ -46,4 +46,5 @@ devices are given in the following sections. :maxdepth: 1 dev-decoder + dev-encoder dev-stateless-decoder diff --git a/Documentation/media/uapi/v4l/pixfmt-v4l2.rst b/Documentation/media/uapi/v4l/pixfmt-v4l2.rst index a8321c348bf8..b7ccc613a382 100644 --- a/Documentation/media/uapi/v4l/pixfmt-v4l2.rst +++ b/Documentation/media/uapi/v4l/pixfmt-v4l2.rst @@ -44,6 +44,11 @@ Single-planar format structure inside the stream, when fed to a stateful mem2mem decoder, the fields may be zero to rely on the decoder to detect the right values. For more details see :ref:`decoder` and format descriptions. + + For compressed formats on the CAPTURE side of a stateful mem2mem + encoder, the fields must be zero, since the coded size is expected to + be calculated internally by the encoder itself, based on the OUTPUT + side. For more details see :ref:`encoder` and format descriptions. * - __u32 - ``pixelformat`` - The pixel format or type of compression, set by the application. diff --git a/Documentation/media/uapi/v4l/v4l2.rst b/Documentation/media/uapi/v4l/v4l2.rst index 97015b9b40b8..e236ea23481b 100644 --- a/Documentation/media/uapi/v4l/v4l2.rst +++ b/Documentation/media/uapi/v4l/v4l2.rst @@ -63,6 +63,7 @@ Authors, in alphabetical order: - Figa, Tomasz - Documented the memory-to-memory decoder interface. + - Documented the memory-to-memory encoder interface. - H Schimek, Michael @@ -75,6 +76,7 @@ Authors, in alphabetical order: - Osciak, Pawel - Documented the memory-to-memory decoder interface. + - Documented the memory-to-memory encoder interface. - Osciak, Pawel diff --git a/Documentation/media/uapi/v4l/vidioc-encoder-cmd.rst b/Documentation/media/uapi/v4l/vidioc-encoder-cmd.rst index c313ca8b8cb5..88281e707476 100644 --- a/Documentation/media/uapi/v4l/vidioc-encoder-cmd.rst +++ b/Documentation/media/uapi/v4l/vidioc-encoder-cmd.rst @@ -51,25 +51,26 @@ To send a command applications must initialize all fields of a struct ``VIDIOC_ENCODER_CMD`` or ``VIDIOC_TRY_ENCODER_CMD`` with a pointer to this structure. -The ``cmd`` field must contain the command code. The ``flags`` field is -currently only used by the STOP command and contains one bit: If the -``V4L2_ENC_CMD_STOP_AT_GOP_END`` flag is set, encoding will continue -until the end of the current *Group Of Pictures*, otherwise it will stop -immediately. +The ``cmd`` field must contain the command code. Some commands use the +``flags`` field for additional information. -A :ref:`read() ` or :ref:`VIDIOC_STREAMON ` -call sends an implicit START command to the encoder if it has not been -started yet. After a STOP command, :ref:`read() ` calls will read +After a STOP command, :ref:`read() ` calls will read the remaining data buffered by the driver. When the buffer is empty, :ref:`read() ` will return zero and the next :ref:`read() ` call will restart the encoder. +A :ref:`read() ` or :ref:`VIDIOC_STREAMON ` +call sends an implicit START command to the encoder if it has not been +started yet. Applies to both queues of mem2mem encoders. + A :ref:`close() ` or :ref:`VIDIOC_STREAMOFF ` call of a streaming file descriptor sends an implicit immediate STOP to -the encoder, and all buffered data is discarded. +the encoder, and all buffered data is discarded. Applies to both queues of +mem2mem encoders. These ioctls are optional, not all drivers may support them. They were -introduced in Linux 2.6.21. +introduced in Linux 2.6.21. They are, however, mandatory for stateful mem2mem +encoders (as further documented in :ref:`encoder`). .. tabularcolumns:: |p{4.4cm}|p{4.4cm}|p{8.7cm}| @@ -109,21 +110,24 @@ introduced in Linux 2.6.21. - 0 - Start the encoder. When the encoder is already running or paused, this command does nothing. No flags are defined for this command. + + For a device implementing the :ref:`encoder`, once the drain sequence + is initiated with the ``V4L2_ENC_CMD_STOP`` command, it must be driven + to completion before this command can be invoked. Any attempt to + invoke the command while the drain sequence is in progress will trigger + an ``EBUSY`` error code. See :ref:`encoder` for more details. * - ``V4L2_ENC_CMD_STOP`` - 1 - Stop the encoder. When the ``V4L2_ENC_CMD_STOP_AT_GOP_END`` flag is set, encoding will continue until the end of the current *Group Of Pictures*, otherwise encoding will stop immediately. When the - encoder is already stopped, this command does nothing. mem2mem - encoders will send a ``V4L2_EVENT_EOS`` event when the last frame - has been encoded and all frames are ready to be dequeued and will - set the ``V4L2_BUF_FLAG_LAST`` buffer flag on the last buffer of - the capture queue to indicate there will be no new buffers - produced to dequeue. This buffer may be empty, indicated by the - driver setting the ``bytesused`` field to 0. Once the - ``V4L2_BUF_FLAG_LAST`` flag was set, the - :ref:`VIDIOC_DQBUF ` ioctl will not block anymore, - but return an ``EPIPE`` error code. + encoder is already stopped, this command does nothing. + + For a device implementing the :ref:`encoder`, the command will initiate + the drain sequence as documented in :ref:`encoder`. No flags or other + arguments are accepted in this case. Any attempt to invoke the command + again before the sequence completes will trigger an ``EBUSY`` error + code. * - ``V4L2_ENC_CMD_PAUSE`` - 2 - Pause the encoder. When the encoder has not been started yet, the @@ -152,6 +156,8 @@ introduced in Linux 2.6.21. - Stop encoding at the end of the current *Group Of Pictures*, rather than immediately. + Does not apply to :ref:`encoder`. + Return Value ============ @@ -160,6 +166,11 @@ On success 0 is returned, on error -1 and the ``errno`` variable is set appropriately. The generic error codes are described at the :ref:`Generic Error Codes ` chapter. +EBUSY + A drain sequence of a device implementing the :ref:`encoder` is still in + progress. It is not allowed to issue another encoder command until it + completes. + EINVAL The ``cmd`` field is invalid. -- 2.22.1 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=-9.8 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT 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 C563FC3A5A1 for ; Thu, 22 Aug 2019 19:46:48 +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 97586233FC for ; Thu, 22 Aug 2019 19:46:48 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="dlVlKPqz" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 97586233FC Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=siol.net 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: Message-Id:Date:Subject:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=7ByTKBPrVHkpEhxUNL29GRFaIKHJe9IPNEbEUytpCs0=; b=dlVlKPqzF/m6h2 +R/a3Ld9PiDJ+JG6goy7veB5larzKMHaCDBhRrNhOIP/cas+B8eF5Em4WWr4FtYvI/TPykgGlN/x+ sFFCv3YIOC97PeUQjvKhwQFFgi7C47A72sSClQ22iQz7tKhGlYiILXJzr9PdI4V/tym7DJnb6Z70V crl1+mAo0oRCq/1T5MF56EpnuSaDzigUPDp+WEToYXDpADMmNy29qvBm5X556AJ2mnsNRJRpq3n+R vmqGqgZroAm+ODXN8EHFt3tsIxNbhzZQW/YB73BedFnNqN47g7ALUHGnxe76h/Tf03H8qTjQHYk68 9JCcLa/n+69CmzX7pkgw==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92 #3 (Red Hat Linux)) id 1i0t2m-0000pF-4T; Thu, 22 Aug 2019 19:46:48 +0000 Received: from mailoutvs23.siol.net ([185.57.226.214] helo=mail.siol.net) by bombadil.infradead.org with esmtps (Exim 4.92 #3 (Red Hat Linux)) id 1i0t1Q-0007mE-S8 for linux-arm-kernel@lists.infradead.org; Thu, 22 Aug 2019 19:45:29 +0000 Received: from localhost (localhost [127.0.0.1]) by mail.siol.net (Postfix) with ESMTP id 1854E5249F3; Thu, 22 Aug 2019 21:45:21 +0200 (CEST) X-Virus-Scanned: amavisd-new at psrvmta11.zcs-production.pri Received: from mail.siol.net ([127.0.0.1]) by localhost (psrvmta11.zcs-production.pri [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id daLeGRkLnMNS; Thu, 22 Aug 2019 21:45:19 +0200 (CEST) Received: from mail.siol.net (localhost [127.0.0.1]) by mail.siol.net (Postfix) with ESMTPS id 350845249EB; Thu, 22 Aug 2019 21:45:19 +0200 (CEST) Received: from localhost.localdomain (cpe-86-58-59-25.static.triera.net [86.58.59.25]) (Authenticated sender: 031275009) by mail.siol.net (Postfix) with ESMTPSA id B46455249F3; Thu, 22 Aug 2019 21:45:16 +0200 (CEST) From: Jernej Skrabec To: mchehab@kernel.org, hverkuil-cisco@xs4all.nl, paul.kocialkowski@bootlin.com, mripard@kernel.org Subject: [PATCH 4/8] media: docs-rst: Document memory-to-memory video encoder interface Date: Thu, 22 Aug 2019 21:44:56 +0200 Message-Id: <20190822194500.2071-5-jernej.skrabec@siol.net> X-Mailer: git-send-email 2.22.1 In-Reply-To: <20190822194500.2071-1-jernej.skrabec@siol.net> References: <20190822194500.2071-1-jernej.skrabec@siol.net> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190822_124525_325364_0E5FFF9D X-CRM114-Status: GOOD ( 16.96 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: devel@driverdev.osuosl.org, jernej.skrabec@siol.net, pawel@osciak.com, acourbot@chromium.org, jonas@kwiboo.se, gregkh@linuxfoundation.org, wens@csie.org, tfiga@chromium.org, kyungmin.park@samsung.com, linux-arm-kernel@lists.infradead.org, linux-media@vger.kernel.org, ezequiel@collabora.com, linux-kernel@vger.kernel.org, m.szyprowski@samsung.com 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 RnJvbTogVG9tYXN6IEZpZ2EgPHRmaWdhQGNocm9taXVtLm9yZz4KCkR1ZSB0byBjb21wbGV4aXR5 IG9mIHRoZSB2aWRlbyBlbmNvZGluZyBwcm9jZXNzLCB0aGUgVjRMMiBkcml2ZXJzIG9mCnN0YXRl ZnVsIGVuY29kZXIgaGFyZHdhcmUgcmVxdWlyZSBzcGVjaWZpYyBzZXF1ZW5jZXMgb2YgVjRMMiBB UEkgY2FsbHMKdG8gYmUgZm9sbG93ZWQuIFRoZXNlIGluY2x1ZGUgY2FwYWJpbGl0eSBlbnVtZXJh dGlvbiwgaW5pdGlhbGl6YXRpb24sCmVuY29kaW5nLCBlbmNvZGUgcGFyYW1ldGVycyBjaGFuZ2Us IGRyYWluIGFuZCByZXNldC4KClNwZWNpZmljcyBvZiB0aGUgYWJvdmUgaGF2ZSBiZWVuIGRpc2N1 c3NlZCBkdXJpbmcgTWVkaWEgV29ya3Nob3BzIGF0CkxpbnV4Q29uIEV1cm9wZSAyMDEyIGluIEJh cmNlbG9uYSBhbmQgdGhlbiBsYXRlciBFbWJlZGRlZCBMaW51eApDb25mZXJlbmNlIEV1cm9wZSAy MDE0IGluIETDvHNzZWxkb3JmLiBUaGUgZGUgZmFjdG8gQ29kZWMgQVBJIHRoYXQKb3JpZ2luYXRl ZCBhdCB0aG9zZSBldmVudHMgd2FzIGxhdGVyIGltcGxlbWVudGVkIGJ5IHRoZSBkcml2ZXJzIHdl IGFscmVhZHkKaGF2ZSBtZXJnZWQgaW4gbWFpbmxpbmUsIHN1Y2ggYXMgczVwLW1mYyBvciBjb2Rh LgoKVGhlIG9ubHkgdGhpbmcgbWlzc2luZyB3YXMgdGhlIHJlYWwgc3BlY2lmaWNhdGlvbiBpbmNs dWRlZCBhcyBhIHBhcnQgb2YKTGludXggTWVkaWEgZG9jdW1lbnRhdGlvbi4gRml4IGl0IG5vdyBh bmQgZG9jdW1lbnQgdGhlIGVuY29kZXIgcGFydCBvZgp0aGUgQ29kZWMgQVBJLgoKU2lnbmVkLW9m Zi1ieTogVG9tYXN6IEZpZ2EgPHRmaWdhQGNocm9taXVtLm9yZz4KU2lnbmVkLW9mZi1ieTogSGFu cyBWZXJrdWlsIDxodmVya3VpbC1jaXNjb0B4czRhbGwubmw+ClNpZ25lZC1vZmYtYnk6IEplcm5l aiBTa3JhYmVjIDxqZXJuZWouc2tyYWJlY0BzaW9sLm5ldD4KLS0tCiBEb2N1bWVudGF0aW9uL21l ZGlhL3VhcGkvdjRsL2Rldi1lbmNvZGVyLnJzdCAgfCA2MDggKysrKysrKysrKysrKysrKysrCiBE b2N1bWVudGF0aW9uL21lZGlhL3VhcGkvdjRsL2Rldi1tZW0ybWVtLnJzdCAgfCAgIDEgKwogRG9j dW1lbnRhdGlvbi9tZWRpYS91YXBpL3Y0bC9waXhmbXQtdjRsMi5yc3QgIHwgICA1ICsKIERvY3Vt ZW50YXRpb24vbWVkaWEvdWFwaS92NGwvdjRsMi5yc3QgICAgICAgICB8ICAgMiArCiAuLi4vbWVk aWEvdWFwaS92NGwvdmlkaW9jLWVuY29kZXItY21kLnJzdCAgICAgfCAgNTEgKy0KIDUgZmlsZXMg Y2hhbmdlZCwgNjQ3IGluc2VydGlvbnMoKyksIDIwIGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUg MTAwNjQ0IERvY3VtZW50YXRpb24vbWVkaWEvdWFwaS92NGwvZGV2LWVuY29kZXIucnN0CgpkaWZm IC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9tZWRpYS91YXBpL3Y0bC9kZXYtZW5jb2Rlci5yc3QgYi9E b2N1bWVudGF0aW9uL21lZGlhL3VhcGkvdjRsL2Rldi1lbmNvZGVyLnJzdApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmU5ZDI5ZDZkZTY3YQotLS0gL2Rldi9udWxsCisr KyBiL0RvY3VtZW50YXRpb24vbWVkaWEvdWFwaS92NGwvZGV2LWVuY29kZXIucnN0CkBAIC0wLDAg KzEsNjA4IEBACisuLiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAorCisuLiBfZW5j b2RlcjoKKworKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KgorTWVtb3J5LXRvLU1lbW9yeSBTdGF0ZWZ1bCBWaWRlbyBFbmNvZGVyIEludGVyZmFjZQorKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorCitBIHN0YXRl ZnVsIHZpZGVvIGVuY29kZXIgdGFrZXMgcmF3IHZpZGVvIGZyYW1lcyBpbiBkaXNwbGF5IG9yZGVy IGFuZCBlbmNvZGVzCit0aGVtIGludG8gYSBieXRlc3RyZWFtLiBJdCBnZW5lcmF0ZXMgY29tcGxl dGUgY2h1bmtzIG9mIHRoZSBieXRlc3RyZWFtLCBpbmNsdWRpbmcKK2FsbCBtZXRhZGF0YSwgaGVh ZGVycywgZXRjLiBUaGUgcmVzdWx0aW5nIGJ5dGVzdHJlYW0gZG9lcyBub3QgcmVxdWlyZSBhbnkK K2Z1cnRoZXIgcG9zdC1wcm9jZXNzaW5nIGJ5IHRoZSBjbGllbnQuCisKK1BlcmZvcm1pbmcgc29m dHdhcmUgc3RyZWFtIHByb2Nlc3NpbmcsIGhlYWRlciBnZW5lcmF0aW9uIGV0Yy4gaW4gdGhlIGRy aXZlcgoraW4gb3JkZXIgdG8gc3VwcG9ydCB0aGlzIGludGVyZmFjZSBpcyBzdHJvbmdseSBkaXNj b3VyYWdlZC4gSW4gY2FzZSBzdWNoCitvcGVyYXRpb25zIGFyZSBuZWVkZWQsIHVzZSBvZiB0aGUg U3RhdGVsZXNzIFZpZGVvIEVuY29kZXIgSW50ZXJmYWNlIChpbgorZGV2ZWxvcG1lbnQpIGlzIHN0 cm9uZ2x5IGFkdmlzZWQuCisKK0NvbnZlbnRpb25zIGFuZCBOb3RhdGlvbnMgVXNlZCBpbiBUaGlz IERvY3VtZW50Cis9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQorCisxLiBUaGUgZ2VuZXJhbCBWNEwyIEFQSSBydWxlcyBhcHBseSBpZiBub3Qgc3BlY2lmaWVk IGluIHRoaXMgZG9jdW1lbnQKKyAgIG90aGVyd2lzZS4KKworMi4gVGhlIG1lYW5pbmcgb2Ygd29y ZHMgIm11c3QiLCAibWF5IiwgInNob3VsZCIsIGV0Yy4gaXMgYXMgcGVyIGBSRkMKKyAgIDIxMTkg PGh0dHBzOi8vdG9vbHMuaWV0Zi5vcmcvaHRtbC9yZmMyMTE5PmBfLgorCiszLiBBbGwgc3RlcHMg bm90IG1hcmtlZCAib3B0aW9uYWwiIGFyZSByZXF1aXJlZC4KKworNC4gOmM6ZnVuYzpgVklESU9D X0dfRVhUX0NUUkxTYCBhbmQgOmM6ZnVuYzpgVklESU9DX1NfRVhUX0NUUkxTYCBtYXkgYmUgdXNl ZAorICAgaW50ZXJjaGFuZ2VhYmx5IHdpdGggOmM6ZnVuYzpgVklESU9DX0dfQ1RSTGAgYW5kIDpj OmZ1bmM6YFZJRElPQ19TX0NUUkxgLAorICAgdW5sZXNzIHNwZWNpZmllZCBvdGhlcndpc2UuCisK KzUuIFNpbmdsZS1wbGFuYXIgQVBJIChzZWUgOnJlZjpgcGxhbmFyLWFwaXNgKSBhbmQgYXBwbGlj YWJsZSBzdHJ1Y3R1cmVzIG1heSBiZQorICAgdXNlZCBpbnRlcmNoYW5nZWFibHkgd2l0aCBtdWx0 aS1wbGFuYXIgQVBJLCB1bmxlc3Mgc3BlY2lmaWVkIG90aGVyd2lzZSwKKyAgIGRlcGVuZGluZyBv biBlbmNvZGVyIGNhcGFiaWxpdGllcyBhbmQgZm9sbG93aW5nIHRoZSBnZW5lcmFsIFY0TDIgZ3Vp ZGVsaW5lcy4KKworNi4gaSA9IFthLi5iXTogc2VxdWVuY2Ugb2YgaW50ZWdlcnMgZnJvbSBhIHRv IGIsIGluY2x1c2l2ZSwgaS5lLiBpID0KKyAgIFswLi4yXTogaSA9IDAsIDEsIDIuCisKKzcuIEdp dmVuIGFuIGBgT1VUUFVUYGAgYnVmZmVyIEEsIHRoZW4gQeKAmSByZXByZXNlbnRzIGEgYnVmZmVy IG9uIHRoZSBgYENBUFRVUkVgYAorICAgcXVldWUgY29udGFpbmluZyBkYXRhIHRoYXQgcmVzdWx0 ZWQgZnJvbSBwcm9jZXNzaW5nIGJ1ZmZlciBBLgorCitHbG9zc2FyeQorPT09PT09PT0KKworUmVm ZXIgdG8gOnJlZjpgZGVjb2Rlci1nbG9zc2FyeWAuCisKK1N0YXRlIE1hY2hpbmUKKz09PT09PT09 PT09PT0KKworLi4ga2VybmVsLXJlbmRlcjo6IERPVAorICAgOmFsdDogRE9UIGRpZ3JhcGggb2Yg ZW5jb2RlciBzdGF0ZSBtYWNoaW5lCisgICA6Y2FwdGlvbjogRW5jb2RlciBTdGF0ZSBNYWNoaW5l CisKKyAgIGRpZ3JhcGggZW5jb2Rlcl9zdGF0ZV9tYWNoaW5lIHsKKyAgICAgICBub2RlIFtzaGFw ZSA9IGRvdWJsZWNpcmNsZSwgbGFiZWw9IkVuY29kaW5nIl0gRW5jb2Rpbmc7CisKKyAgICAgICBu b2RlIFtzaGFwZSA9IGNpcmNsZSwgbGFiZWw9IkluaXRpYWxpemF0aW9uIl0gSW5pdGlhbGl6YXRp b247CisgICAgICAgbm9kZSBbc2hhcGUgPSBjaXJjbGUsIGxhYmVsPSJTdG9wcGVkIl0gU3RvcHBl ZDsKKyAgICAgICBub2RlIFtzaGFwZSA9IGNpcmNsZSwgbGFiZWw9IkRyYWluIl0gRHJhaW47Cisg ICAgICAgbm9kZSBbc2hhcGUgPSBjaXJjbGUsIGxhYmVsPSJSZXNldCJdIFJlc2V0OworCisgICAg ICAgbm9kZSBbc2hhcGUgPSBwb2ludF07IHFpCisgICAgICAgcWkgLT4gSW5pdGlhbGl6YXRpb24g WyBsYWJlbCA9ICJvcGVuKCkiIF07CisKKyAgICAgICBJbml0aWFsaXphdGlvbiAtPiBFbmNvZGlu ZyBbIGxhYmVsID0gIkJvdGggcXVldWVzIHN0cmVhbWluZyIgXTsKKworICAgICAgIEVuY29kaW5n IC0+IERyYWluIFsgbGFiZWwgPSAiVjRMMl9FTkNfQ01EX1NUT1AiIF07CisgICAgICAgRW5jb2Rp bmcgLT4gUmVzZXQgWyBsYWJlbCA9ICJWSURJT0NfU1RSRUFNT0ZGKENBUFRVUkUpIiBdOworICAg ICAgIEVuY29kaW5nIC0+IFN0b3BwZWQgWyBsYWJlbCA9ICJWSURJT0NfU1RSRUFNT0ZGKE9VVFBV VCkiIF07CisgICAgICAgRW5jb2RpbmcgLT4gRW5jb2Rpbmc7CisKKyAgICAgICBEcmFpbiAtPiBT dG9wcGVkIFsgbGFiZWwgPSAiQWxsIENBUFRVUkVcbmJ1ZmZlcnMgZGVxdWV1ZWRcbm9yXG5WSURJ T0NfU1RSRUFNT0ZGKE9VVFBVVCkiIF07CisgICAgICAgRHJhaW4gLT4gUmVzZXQgWyBsYWJlbCA9 ICJWSURJT0NfU1RSRUFNT0ZGKENBUFRVUkUpIiBdOworCisgICAgICAgUmVzZXQgLT4gRW5jb2Rp bmcgWyBsYWJlbCA9ICJWSURJT0NfU1RSRUFNT04oQ0FQVFVSRSkiIF07CisgICAgICAgUmVzZXQg LT4gSW5pdGlhbGl6YXRpb24gWyBsYWJlbCA9ICJWSURJT0NfUkVRQlVGUyhPVVRQVVQsIDApIiBd OworCisgICAgICAgU3RvcHBlZCAtPiBFbmNvZGluZyBbIGxhYmVsID0gIlY0TDJfRU5DX0NNRF9T VEFSVFxub3JcblZJRElPQ19TVFJFQU1PTihPVVRQVVQpIiBdOworICAgICAgIFN0b3BwZWQgLT4g UmVzZXQgWyBsYWJlbCA9ICJWSURJT0NfU1RSRUFNT0ZGKENBUFRVUkUpIiBdOworICAgfQorCitR dWVyeWluZyBDYXBhYmlsaXRpZXMKKz09PT09PT09PT09PT09PT09PT09PQorCisxLiBUbyBlbnVt ZXJhdGUgdGhlIHNldCBvZiBjb2RlZCBmb3JtYXRzIHN1cHBvcnRlZCBieSB0aGUgZW5jb2Rlciwg dGhlCisgICBjbGllbnQgbWF5IGNhbGwgOmM6ZnVuYzpgVklESU9DX0VOVU1fRk1UYCBvbiBgYENB UFRVUkVgYC4KKworICAgKiBUaGUgZnVsbCBzZXQgb2Ygc3VwcG9ydGVkIGZvcm1hdHMgd2lsbCBi ZSByZXR1cm5lZCwgcmVnYXJkbGVzcyBvZiB0aGUKKyAgICAgZm9ybWF0IHNldCBvbiBgYE9VVFBV VGBgLgorCisyLiBUbyBlbnVtZXJhdGUgdGhlIHNldCBvZiBzdXBwb3J0ZWQgcmF3IGZvcm1hdHMs IHRoZSBjbGllbnQgbWF5IGNhbGwKKyAgIDpjOmZ1bmM6YFZJRElPQ19FTlVNX0ZNVGAgb24gYGBP VVRQVVRgYC4KKworICAgKiBPbmx5IHRoZSBmb3JtYXRzIHN1cHBvcnRlZCBmb3IgdGhlIGZvcm1h dCBjdXJyZW50bHkgYWN0aXZlIG9uIGBgQ0FQVFVSRWBgCisgICAgIHdpbGwgYmUgcmV0dXJuZWQu CisKKyAgICogSW4gb3JkZXIgdG8gZW51bWVyYXRlIHJhdyBmb3JtYXRzIHN1cHBvcnRlZCBieSBh IGdpdmVuIGNvZGVkIGZvcm1hdCwKKyAgICAgdGhlIGNsaWVudCBtdXN0IGZpcnN0IHNldCB0aGF0 IGNvZGVkIGZvcm1hdCBvbiBgYENBUFRVUkVgYCBhbmQgdGhlbgorICAgICBlbnVtZXJhdGUgdGhl IGZvcm1hdHMgb24gYGBPVVRQVVRgYC4KKworMy4gVGhlIGNsaWVudCBtYXkgdXNlIDpjOmZ1bmM6 YFZJRElPQ19FTlVNX0ZSQU1FU0laRVNgIHRvIGRldGVjdCBzdXBwb3J0ZWQKKyAgIHJlc29sdXRp b25zIGZvciBhIGdpdmVuIGZvcm1hdCwgcGFzc2luZyBkZXNpcmVkIHBpeGVsIGZvcm1hdCBpbgor ICAgOmM6dHlwZTpgdjRsMl9mcm1zaXplZW51bWAgYGBwaXhlbF9mb3JtYXRgYC4KKworICAgKiBW YWx1ZXMgcmV0dXJuZWQgYnkgOmM6ZnVuYzpgVklESU9DX0VOVU1fRlJBTUVTSVpFU2AgZm9yIGEg Y29kZWQgcGl4ZWwKKyAgICAgZm9ybWF0IHdpbGwgaW5jbHVkZSBhbGwgcG9zc2libGUgY29kZWQg cmVzb2x1dGlvbnMgc3VwcG9ydGVkIGJ5IHRoZQorICAgICBlbmNvZGVyIGZvciBnaXZlbiBjb2Rl ZCBwaXhlbCBmb3JtYXQuCisKKyAgICogVmFsdWVzIHJldHVybmVkIGJ5IDpjOmZ1bmM6YFZJRElP Q19FTlVNX0ZSQU1FU0laRVNgIGZvciBhIHJhdyBwaXhlbCBmb3JtYXQKKyAgICAgd2lsbCBpbmNs dWRlIGFsbCBwb3NzaWJsZSBmcmFtZSBidWZmZXIgcmVzb2x1dGlvbnMgc3VwcG9ydGVkIGJ5IHRo ZQorICAgICBlbmNvZGVyIGZvciBnaXZlbiByYXcgcGl4ZWwgZm9ybWF0IGFuZCBjb2RlZCBmb3Jt YXQgY3VycmVudGx5IHNldCBvbgorICAgICBgYENBUFRVUkVgYC4KKworNC4gU3VwcG9ydGVkIHBy b2ZpbGVzIGFuZCBsZXZlbHMgZm9yIHRoZSBjb2RlZCBmb3JtYXQgY3VycmVudGx5IHNldCBvbgor ICAgYGBDQVBUVVJFYGAsIGlmIGFwcGxpY2FibGUsIG1heSBiZSBxdWVyaWVkIHVzaW5nIHRoZWly IHJlc3BlY3RpdmUgY29udHJvbHMKKyAgIHZpYSA6YzpmdW5jOmBWSURJT0NfUVVFUllDVFJMYC4K KworNS4gQW55IGFkZGl0aW9uYWwgZW5jb2RlciBjYXBhYmlsaXRpZXMgbWF5IGJlIGRpc2NvdmVy ZWQgYnkgcXVlcnlpbmcKKyAgIHRoZWlyIHJlc3BlY3RpdmUgY29udHJvbHMuCisKK0luaXRpYWxp emF0aW9uCis9PT09PT09PT09PT09PQorCisxLiBTZXQgdGhlIGNvZGVkIGZvcm1hdCBvbiB0aGUg YGBDQVBUVVJFYGAgcXVldWUgdmlhIDpjOmZ1bmM6YFZJRElPQ19TX0ZNVGAKKworICAgKiAqKlJl cXVpcmVkIGZpZWxkczoqKgorCisgICAgIGBgdHlwZWBgCisgICAgICAgICBhIGBgVjRMMl9CVUZf VFlQRV8qYGAgZW51bSBhcHByb3ByaWF0ZSBmb3IgYGBDQVBUVVJFYGAuCisKKyAgICAgYGBwaXhl bGZvcm1hdGBgCisgICAgICAgICB0aGUgY29kZWQgZm9ybWF0IHRvIGJlIHByb2R1Y2VkLgorCisg ICAgIGBgc2l6ZWltYWdlYGAKKyAgICAgICAgIGRlc2lyZWQgc2l6ZSBvZiBgYENBUFRVUkVgYCBi dWZmZXJzOyB0aGUgZW5jb2RlciBtYXkgYWRqdXN0IGl0IHRvCisgICAgICAgICBtYXRjaCBoYXJk d2FyZSByZXF1aXJlbWVudHMuCisKKyAgICAgYGB3aWR0aGBgLCBgYGhlaWdodGBgCisgICAgICAg ICBpZ25vcmVkIChyZWFkLW9ubHkpLgorCisgICAgIG90aGVyIGZpZWxkcworICAgICAgICAgZm9s bG93IHN0YW5kYXJkIHNlbWFudGljcy4KKworICAgKiAqKlJldHVybiBmaWVsZHM6KioKKworICAg ICBgYHNpemVpbWFnZWBgCisgICAgICAgICBhZGp1c3RlZCBzaXplIG9mIGBgQ0FQVFVSRWBgIGJ1 ZmZlcnMuCisKKyAgICAgYGB3aWR0aGBgLCBgYGhlaWdodGBgCisgICAgICAgICB0aGUgY29kZWQg c2l6ZSBzZWxlY3RlZCBieSB0aGUgZW5jb2RlciBiYXNlZCBvbiBjdXJyZW50IHN0YXRlLCBlLmcu CisgICAgICAgICBgYE9VVFBVVGBgIGZvcm1hdCwgc2VsZWN0aW9uIHJlY3RhbmdsZXMsIGV0Yy4g KHJlYWQtb25seSkuCisKKyAgIC4uIGltcG9ydGFudDo6CisKKyAgICAgIENoYW5naW5nIHRoZSBg YENBUFRVUkVgYCBmb3JtYXQgbWF5IGNoYW5nZSB0aGUgY3VycmVudGx5IHNldCBgYE9VVFBVVGBg CisgICAgICBmb3JtYXQuIEhvdyB0aGUgbmV3IGBgT1VUUFVUYGAgZm9ybWF0IGlzIGRldGVybWlu ZWQgaXMgdXAgdG8gdGhlIGVuY29kZXIKKyAgICAgIGFuZCB0aGUgY2xpZW50IG11c3TCoGVuc3Vy ZSBpdCBtYXRjaGVzIGl0cyBuZWVkcyBhZnRlcndhcmRzLgorCisyLiAqKk9wdGlvbmFsLioqIEVu dW1lcmF0ZSBzdXBwb3J0ZWQgYGBPVVRQVVRgYCBmb3JtYXRzIChyYXcgZm9ybWF0cyBmb3IKKyAg IHNvdXJjZSkgZm9yIHRoZSBzZWxlY3RlZCBjb2RlZCBmb3JtYXQgdmlhIDpjOmZ1bmM6YFZJRElP Q19FTlVNX0ZNVGAuCisKKyAgICogKipSZXF1aXJlZCBmaWVsZHM6KioKKworICAgICBgYHR5cGVg YAorICAgICAgICAgYSBgYFY0TDJfQlVGX1RZUEVfKmBgIGVudW0gYXBwcm9wcmlhdGUgZm9yIGBg T1VUUFVUYGAuCisKKyAgICAgb3RoZXIgZmllbGRzCisgICAgICAgICBmb2xsb3cgc3RhbmRhcmQg c2VtYW50aWNzLgorCisgICAqICoqUmV0dXJuIGZpZWxkczoqKgorCisgICAgIGBgcGl4ZWxmb3Jt YXRgYAorICAgICAgICAgcmF3IGZvcm1hdCBzdXBwb3J0ZWQgZm9yIHRoZSBjb2RlZCBmb3JtYXQg Y3VycmVudGx5IHNlbGVjdGVkIG9uCisgICAgICAgICB0aGUgYGBDQVBUVVJFYGAgcXVldWUuCisK KyAgICAgb3RoZXIgZmllbGRzCisgICAgICAgICBmb2xsb3cgc3RhbmRhcmQgc2VtYW50aWNzLgor CiszLiBTZXQgdGhlIHJhdyBzb3VyY2UgZm9ybWF0IG9uIHRoZSBgYE9VVFBVVGBgIHF1ZXVlIHZp YQorICAgOmM6ZnVuYzpgVklESU9DX1NfRk1UYC4KKworICAgKiAqKlJlcXVpcmVkIGZpZWxkczoq KgorCisgICAgIGBgdHlwZWBgCisgICAgICAgICBhIGBgVjRMMl9CVUZfVFlQRV8qYGAgZW51bSBh cHByb3ByaWF0ZSBmb3IgYGBPVVRQVVRgYC4KKworICAgICBgYHBpeGVsZm9ybWF0YGAKKyAgICAg ICAgIHJhdyBmb3JtYXQgb2YgdGhlIHNvdXJjZS4KKworICAgICBgYHdpZHRoYGAsIGBgaGVpZ2h0 YGAKKyAgICAgICAgIHNvdXJjZSByZXNvbHV0aW9uLgorCisgICAgIG90aGVyIGZpZWxkcworICAg ICAgICAgZm9sbG93IHN0YW5kYXJkIHNlbWFudGljcy4KKworICAgKiAqKlJldHVybiBmaWVsZHM6 KioKKworICAgICBgYHdpZHRoYGAsIGBgaGVpZ2h0YGAKKyAgICAgICAgIG1heSBiZSBhZGp1c3Rl ZCB0byBtYXRjaCBlbmNvZGVyIG1pbmltdW1zLCBtYXhpbXVtcyBhbmQgYWxpZ25tZW50CisgICAg ICAgICByZXF1aXJlbWVudHMsIGFzIHJlcXVpcmVkIGJ5IHRoZSBjdXJyZW50bHkgc2VsZWN0ZWQg Zm9ybWF0cywgYXMKKyAgICAgICAgIHJlcG9ydGVkIGJ5IDpjOmZ1bmM6YFZJRElPQ19FTlVNX0ZS QU1FU0laRVNgLgorCisgICAgIG90aGVyIGZpZWxkcworICAgICAgICAgZm9sbG93IHN0YW5kYXJk IHNlbWFudGljcy4KKworICAgKiBTZXR0aW5nIHRoZSBgYE9VVFBVVGBgIGZvcm1hdCB3aWxsIHJl c2V0IHRoZSBzZWxlY3Rpb24gcmVjdGFuZ2xlcyB0byB0aGVpcgorICAgICBkZWZhdWx0IHZhbHVl cywgYmFzZWQgb24gdGhlIG5ldyByZXNvbHV0aW9uLCBhcyBkZXNjcmliZWQgaW4gdGhlIG5leHQK KyAgICAgc3RlcC4KKworNC4gKipPcHRpb25hbC4qKiBTZXQgdGhlIHZpc2libGUgcmVzb2x1dGlv biBmb3IgdGhlIHN0cmVhbSBtZXRhZGF0YSB2aWEKKyAgIDpjOmZ1bmM6YFZJRElPQ19TX1NFTEVD VElPTmAgb24gdGhlIGBgT1VUUFVUYGAgcXVldWUgaWYgaXQgaXMgZGVzaXJlZAorICAgdG8gYmUg ZGlmZmVyZW50IHRoYW4gdGhlIGZ1bGwgT1VUUFVUIHJlc29sdXRpb24uCisKKyAgICogKipSZXF1 aXJlZCBmaWVsZHM6KioKKworICAgICBgYHR5cGVgYAorICAgICAgICAgYSBgYFY0TDJfQlVGX1RZ UEVfKmBgIGVudW0gYXBwcm9wcmlhdGUgZm9yIGBgT1VUUFVUYGAuCisKKyAgICAgYGB0YXJnZXRg YAorICAgICAgICAgc2V0IHRvIGBgVjRMMl9TRUxfVEdUX0NST1BgYC4KKworICAgICBgYHIubGVm dGBgLCBgYHIudG9wYGAsIGBgci53aWR0aGBgLCBgYHIuaGVpZ2h0YGAKKyAgICAgICAgIHZpc2li bGUgcmVjdGFuZ2xlOyB0aGlzIG11c3QgZml0IHdpdGhpbiB0aGUgYFY0TDJfU0VMX1RHVF9DUk9Q X0JPVU5EU2AKKyAgICAgICAgIHJlY3RhbmdsZSBhbmQgbWF5IGJlIHN1YmplY3QgdG8gYWRqdXN0 bWVudCB0byBtYXRjaCBjb2RlYyBhbmQKKyAgICAgICAgIGhhcmR3YXJlIGNvbnN0cmFpbnRzLgor CisgICAqICoqUmV0dXJuIGZpZWxkczoqKgorCisgICAgIGBgci5sZWZ0YGAsIGBgci50b3BgYCwg YGByLndpZHRoYGAsIGBgci5oZWlnaHRgYAorICAgICAgICAgdmlzaWJsZSByZWN0YW5nbGUgYWRq dXN0ZWQgYnkgdGhlIGVuY29kZXIuCisKKyAgICogVGhlIGZvbGxvd2luZyBzZWxlY3Rpb24gdGFy Z2V0cyBhcmUgc3VwcG9ydGVkIG9uIGBgT1VUUFVUYGA6CisKKyAgICAgYGBWNEwyX1NFTF9UR1Rf Q1JPUF9CT1VORFNgYAorICAgICAgICAgZXF1YWwgdG8gdGhlIGZ1bGwgc291cmNlIGZyYW1lLCBt YXRjaGluZyB0aGUgYWN0aXZlIGBgT1VUUFVUYGAKKyAgICAgICAgIGZvcm1hdC4KKworICAgICBg YFY0TDJfU0VMX1RHVF9DUk9QX0RFRkFVTFRgYAorICAgICAgICAgZXF1YWwgdG8gYGBWNEwyX1NF TF9UR1RfQ1JPUF9CT1VORFNgYC4KKworICAgICBgYFY0TDJfU0VMX1RHVF9DUk9QYGAKKyAgICAg ICAgIHJlY3RhbmdsZSB3aXRoaW4gdGhlIHNvdXJjZSBidWZmZXIgdG8gYmUgZW5jb2RlZCBpbnRv IHRoZQorICAgICAgICAgYGBDQVBUVVJFYGAgc3RyZWFtOyBkZWZhdWx0cyB0byBgYFY0TDJfU0VM X1RHVF9DUk9QX0RFRkFVTFRgYC4KKworICAgICAgICAgLi4gbm90ZTo6CisKKyAgICAgICAgICAg IEEgY29tbW9uIHVzZSBjYXNlIGZvciB0aGlzIHNlbGVjdGlvbiB0YXJnZXQgaXMgZW5jb2Rpbmcg YSBzb3VyY2UKKyAgICAgICAgICAgIHZpZGVvIHdpdGggYSByZXNvbHV0aW9uIHRoYXQgaXMgbm90 IGEgbXVsdGlwbGUgb2YgYSBtYWNyb2Jsb2NrLAorICAgICAgICAgICAgZS5nLiAgdGhlIGNvbW1v biAxOTIweDEwODAgcmVzb2x1dGlvbiBtYXkgcmVxdWlyZSB0aGUgc291cmNlCisgICAgICAgICAg ICBidWZmZXJzIHRvIGJlIGFsaWduZWQgdG8gMTkyMHgxMDg4IGZvciBjb2RlY3Mgd2l0aCAxNngx NiBtYWNyb2Jsb2NrCisgICAgICAgICAgICBzaXplLiBUbyBhdm9pZCBlbmNvZGluZyB0aGUgcGFk ZGluZywgdGhlIGNsaWVudCBuZWVkcyB0byBleHBsaWNpdGx5CisgICAgICAgICAgICBjb25maWd1 cmUgdGhpcyBzZWxlY3Rpb24gdGFyZ2V0IHRvIDE5MjB4MTA4MC4KKworICAgLi4gd2FybmluZzo6 CisKKyAgICAgIFRoZSBlbmNvZGVyIG1heSBhZGp1c3QgdGhlIGNyb3AvY29tcG9zZSByZWN0YW5n bGVzIHRvIHRoZSBuZWFyZXN0CisgICAgICBzdXBwb3J0ZWQgb25lcyB0byBtZWV0IGNvZGVjIGFu ZCBoYXJkd2FyZSByZXF1aXJlbWVudHMuIFRoZSBjbGllbnQgbmVlZHMKKyAgICAgIHRvIGNoZWNr IHRoZSBhZGp1c3RlZCByZWN0YW5nbGUgcmV0dXJuZWQgYnkgOmM6ZnVuYzpgVklESU9DX1NfU0VM RUNUSU9OYC4KKworNS4gQWxsb2NhdGUgYnVmZmVycyBmb3IgYm90aCBgYE9VVFBVVGBgIGFuZCBg YENBUFRVUkVgYCB2aWEKKyAgIDpjOmZ1bmM6YFZJRElPQ19SRVFCVUZTYC4gVGhpcyBtYXkgYmUg cGVyZm9ybWVkIGluIGFueSBvcmRlci4KKworICAgKiAqKlJlcXVpcmVkIGZpZWxkczoqKgorCisg ICAgIGBgY291bnRgYAorICAgICAgICAgcmVxdWVzdGVkIG51bWJlciBvZiBidWZmZXJzIHRvIGFs bG9jYXRlOyBncmVhdGVyIHRoYW4gemVyby4KKworICAgICBgYHR5cGVgYAorICAgICAgICAgYSBg YFY0TDJfQlVGX1RZUEVfKmBgIGVudW0gYXBwcm9wcmlhdGUgZm9yIGBgT1VUUFVUYGAgb3IKKyAg ICAgICAgIGBgQ0FQVFVSRWBgLgorCisgICAgIG90aGVyIGZpZWxkcworICAgICAgICAgZm9sbG93 IHN0YW5kYXJkIHNlbWFudGljcy4KKworICAgKiAqKlJldHVybiBmaWVsZHM6KioKKworICAgICBg YGNvdW50YGAKKyAgICAgICAgICBhY3R1YWwgbnVtYmVyIG9mIGJ1ZmZlcnMgYWxsb2NhdGVkLgor CisgICAuLiB3YXJuaW5nOjoKKworICAgICAgVGhlIGFjdHVhbCBudW1iZXIgb2YgYWxsb2NhdGVk IGJ1ZmZlcnMgbWF5IGRpZmZlciBmcm9tIHRoZSBgYGNvdW50YGAKKyAgICAgIGdpdmVuLiBUaGUg Y2xpZW50IG11c3QgY2hlY2sgdGhlIHVwZGF0ZWQgdmFsdWUgb2YgYGBjb3VudGBgIGFmdGVyIHRo ZQorICAgICAgY2FsbCByZXR1cm5zLgorCisgICAuLiBub3RlOjoKKworICAgICAgVG8gYWxsb2Nh dGUgbW9yZSB0aGFuIHRoZSBtaW5pbXVtIG51bWJlciBvZiBPVVRQVVQgYnVmZmVycyAoZm9yIHBp cGVsaW5lCisgICAgICBkZXB0aCksIHRoZSBjbGllbnQgbWF5IHF1ZXJ5IHRoZSBgYFY0TDJfQ0lE X01JTl9CVUZGRVJTX0ZPUl9PVVRQVVRgYAorICAgICAgY29udHJvbCB0byBnZXQgdGhlIG1pbmlt dW0gbnVtYmVyIG9mIGJ1ZmZlcnMgcmVxdWlyZWQsIGFuZCBwYXNzIHRoZQorICAgICAgb2J0YWlu ZWQgdmFsdWUgcGx1cyB0aGUgbnVtYmVyIG9mIGFkZGl0aW9uYWwgYnVmZmVycyBuZWVkZWQgaW4g dGhlCisgICAgICBgYGNvdW50YGAgZmllbGQgdG8gOmM6ZnVuYzpgVklESU9DX1JFUUJVRlNgLgor CisgICBBbHRlcm5hdGl2ZWx5LCA6YzpmdW5jOmBWSURJT0NfQ1JFQVRFX0JVRlNgIGNhbiBiZSB1 c2VkIHRvIGhhdmUgbW9yZQorICAgY29udHJvbCBvdmVyIGJ1ZmZlciBhbGxvY2F0aW9uLgorCisg ICAqICoqUmVxdWlyZWQgZmllbGRzOioqCisKKyAgICAgYGBjb3VudGBgCisgICAgICAgICByZXF1 ZXN0ZWQgbnVtYmVyIG9mIGJ1ZmZlcnMgdG8gYWxsb2NhdGU7IGdyZWF0ZXIgdGhhbiB6ZXJvLgor CisgICAgIGBgdHlwZWBgCisgICAgICAgICBhIGBgVjRMMl9CVUZfVFlQRV8qYGAgZW51bSBhcHBy b3ByaWF0ZSBmb3IgYGBPVVRQVVRgYC4KKworICAgICBvdGhlciBmaWVsZHMKKyAgICAgICAgIGZv bGxvdyBzdGFuZGFyZCBzZW1hbnRpY3MuCisKKyAgICogKipSZXR1cm4gZmllbGRzOioqCisKKyAg ICAgYGBjb3VudGBgCisgICAgICAgICBhZGp1c3RlZCB0byB0aGUgbnVtYmVyIG9mIGFsbG9jYXRl ZCBidWZmZXJzLgorCis2LiBCZWdpbiBzdHJlYW1pbmcgb24gYm90aCBgYE9VVFBVVGBgIGFuZCBg YENBUFRVUkVgYCBxdWV1ZXMgdmlhCisgICA6YzpmdW5jOmBWSURJT0NfU1RSRUFNT05gLiBUaGlz IG1heSBiZSBwZXJmb3JtZWQgaW4gYW55IG9yZGVyLiBUaGUgYWN0dWFsCisgICBlbmNvZGluZyBw cm9jZXNzIHN0YXJ0cyB3aGVuIGJvdGggcXVldWVzIHN0YXJ0IHN0cmVhbWluZy4KKworLi4gbm90 ZTo6CisKKyAgIElmIHRoZSBjbGllbnQgc3RvcHMgdGhlIGBgQ0FQVFVSRWBgIHF1ZXVlIGR1cmlu ZyB0aGUgZW5jb2RlIHByb2Nlc3MgYW5kIHRoZW4KKyAgIHJlc3RhcnRzIGl0IGFnYWluLCB0aGUg ZW5jb2RlciB3aWxsIGJlZ2luIGdlbmVyYXRpbmcgYSBzdHJlYW0gaW5kZXBlbmRlbnQKKyAgIGZy b20gdGhlIHN0cmVhbSBnZW5lcmF0ZWQgYmVmb3JlIHRoZSBzdG9wLiBUaGUgZXhhY3QgY29uc3Ry YWludHMgZGVwZW5kCisgICBvbiB0aGUgY29kZWQgZm9ybWF0LCBidXQgbWF5IGluY2x1ZGUgdGhl IGZvbGxvd2luZyBpbXBsaWNhdGlvbnM6CisKKyAgICogZW5jb2RlZCBmcmFtZXMgcHJvZHVjZWQg YWZ0ZXIgdGhlIHJlc3RhcnQgbXVzdCBub3QgcmVmZXJlbmNlIGFueQorICAgICBmcmFtZXMgcHJv ZHVjZWQgYmVmb3JlIHRoZSBzdG9wLCBlLmcuIG5vIGxvbmcgdGVybSByZWZlcmVuY2VzIGZvcgor ICAgICBILjI2NC9IRVZDLAorCisgICAqIGFueSBoZWFkZXJzIHRoYXQgbXVzdCBiZSBpbmNsdWRl ZCBpbiBhIHN0YW5kYWxvbmUgc3RyZWFtIG11c3QgYmUKKyAgICAgcHJvZHVjZWQgYWdhaW4sIGUu Zy4gU1BTIGFuZCBQUFMgZm9yIEguMjY0L0hFVkMuCisKK0VuY29kaW5nCis9PT09PT09PQorCitU aGlzIHN0YXRlIGlzIHJlYWNoZWQgYWZ0ZXIgdGhlIGBJbml0aWFsaXphdGlvbmAgc2VxdWVuY2Ug ZmluaXNoZXMKK3N1Y2Nlc3NmdWxseS4gIEluIHRoaXMgc3RhdGUsIHRoZSBjbGllbnQgcXVldWVz IGFuZCBkZXF1ZXVlcyBidWZmZXJzIHRvIGJvdGgKK3F1ZXVlcyB2aWEgOmM6ZnVuYzpgVklESU9D X1FCVUZgIGFuZCA6YzpmdW5jOmBWSURJT0NfRFFCVUZgLCBmb2xsb3dpbmcgdGhlCitzdGFuZGFy ZCBzZW1hbnRpY3MuCisKK1RoZSBjb250ZW50IG9mIGVuY29kZWQgYGBDQVBUVVJFYGAgYnVmZmVy cyBkZXBlbmRzIG9uIHRoZSBhY3RpdmUgY29kZWQgcGl4ZWwKK2Zvcm1hdCBhbmQgbWF5IGJlIGFm ZmVjdGVkIGJ5IGNvZGVjLXNwZWNpZmljIGV4dGVuZGVkIGNvbnRyb2xzLCBhcyBzdGF0ZWQKK2lu IHRoZSBkb2N1bWVudGF0aW9uIG9mIGVhY2ggZm9ybWF0LgorCitCb3RoIHF1ZXVlcyBvcGVyYXRl IGluZGVwZW5kZW50bHksIGZvbGxvd2luZyBzdGFuZGFyZCBiZWhhdmlvciBvZiBWNEwyIGJ1ZmZl cgorcXVldWVzIGFuZCBtZW1vcnktdG8tbWVtb3J5IGRldmljZXMuIEluIGFkZGl0aW9uLCB0aGUg b3JkZXIgb2YgZW5jb2RlZCBmcmFtZXMKK2RlcXVldWVkIGZyb20gdGhlIGBgQ0FQVFVSRWBgIHF1 ZXVlIG1heSBkaWZmZXIgZnJvbSB0aGUgb3JkZXIgb2YgcXVldWluZyByYXcKK2ZyYW1lcyB0byB0 aGUgYGBPVVRQVVRgYCBxdWV1ZSwgZHVlIHRvIHByb3BlcnRpZXMgb2YgdGhlIHNlbGVjdGVkIGNv ZGVkIGZvcm1hdCwKK2UuZy4gZnJhbWUgcmVvcmRlcmluZy4KKworVGhlIGNsaWVudCBtdXN0IG5v dCBhc3N1bWUgYW55IGRpcmVjdCByZWxhdGlvbnNoaXAgYmV0d2VlbiBgYENBUFRVUkVgYCBhbmQK K2BgT1VUUFVUYGAgYnVmZmVycyBhbmQgYW55IHNwZWNpZmljIHRpbWluZyBvZiBidWZmZXJzIGJl Y29taW5nCithdmFpbGFibGUgdG8gZGVxdWV1ZS4gU3BlY2lmaWNhbGx5OgorCisqIGEgYnVmZmVy IHF1ZXVlZCB0byBgYE9VVFBVVGBgIG1heSByZXN1bHQgaW4gbW9yZSB0aGFuIG9uZSBidWZmZXIg cHJvZHVjZWQgb24KKyAgYGBDQVBUVVJFYGAgKGlmIHJldHVybmluZyBhbiBlbmNvZGVkIGZyYW1l IGFsbG93ZWQgdGhlIGVuY29kZXIgdG8gcmV0dXJuIGEKKyAgZnJhbWUgdGhhdCBwcmVjZWRlZCBp dCBpbiBkaXNwbGF5LCBidXQgc3VjY2VlZGVkIGl0IGluIHRoZSBkZWNvZGUgb3JkZXIpLAorCisq IGEgYnVmZmVyIHF1ZXVlZCB0byBgYE9VVFBVVGBgIG1heSByZXN1bHQgaW4gYSBidWZmZXIgYmVp bmcgcHJvZHVjZWQgb24KKyAgYGBDQVBUVVJFYGAgbGF0ZXIgaW50byBlbmNvZGUgcHJvY2Vzcywg YW5kL29yIGFmdGVyIHByb2Nlc3NpbmcgZnVydGhlcgorICBgYE9VVFBVVGBgIGJ1ZmZlcnMsIG9y IGJlIHJldHVybmVkIG91dCBvZiBvcmRlciwgZS5nLiBpZiBkaXNwbGF5CisgIHJlb3JkZXJpbmcg aXMgdXNlZCwKKworKiBidWZmZXJzIG1heSBiZWNvbWUgYXZhaWxhYmxlIG9uIHRoZSBgYENBUFRV UkVgYCBxdWV1ZSB3aXRob3V0IGFkZGl0aW9uYWwKKyAgYnVmZmVycyBxdWV1ZWQgdG8gYGBPVVRQ VVRgYCAoZS5nLiBkdXJpbmcgZHJhaW4gb3IgYGBFT1NgYCksIGJlY2F1c2Ugb2YgdGhlCisgIGBg T1VUUFVUYGAgYnVmZmVycyBxdWV1ZWQgaW4gdGhlIHBhc3Qgd2hvc2UgZGVjb2RpbmcgcmVzdWx0 cyBhcmUgb25seQorICBhdmFpbGFibGUgYXQgbGF0ZXIgdGltZSwgZHVlIHRvIHNwZWNpZmljcyBv ZiB0aGUgZGVjb2RpbmcgcHJvY2VzcywKKworKiBidWZmZXJzIHF1ZXVlZCB0byBgYE9VVFBVVGBg IG1heSBub3QgYmVjb21lIGF2YWlsYWJsZSB0byBkZXF1ZXVlIGluc3RhbnRseQorICBhZnRlciBi ZWluZyBlbmNvZGVkIGludG8gYSBjb3JyZXNwb25kaW5nIGBgQ0FQVFVSRWBgIGJ1ZmZlciwgZS5n LiBpZiB0aGUKKyAgZW5jb2RlciBuZWVkcyB0byB1c2UgdGhlIGZyYW1lIGFzIGEgcmVmZXJlbmNl IGZvciBlbmNvZGluZyBmdXJ0aGVyIGZyYW1lcy4KKworLi4gbm90ZTo6CisKKyAgIFRvIGFsbG93 IG1hdGNoaW5nIGVuY29kZWQgYGBDQVBUVVJFYGAgYnVmZmVycyB3aXRoIGBgT1VUUFVUYGAgYnVm ZmVycyB0aGV5CisgICBvcmlnaW5hdGVkIGZyb20sIHRoZSBjbGllbnQgY2FuIHNldCB0aGUgYGB0 aW1lc3RhbXBgYCBmaWVsZCBvZiB0aGUKKyAgIDpjOnR5cGU6YHY0bDJfYnVmZmVyYCBzdHJ1Y3Qg d2hlbiBxdWV1aW5nIGFuIGBgT1VUUFVUYGAgYnVmZmVyLiBUaGUKKyAgIGBgQ0FQVFVSRWBgIGJ1 ZmZlcihzKSwgd2hpY2ggcmVzdWx0ZWQgZnJvbSBlbmNvZGluZyB0aGF0IGBgT1VUUFVUYGAgYnVm ZmVyCisgICB3aWxsIGhhdmUgdGhlaXIgYGB0aW1lc3RhbXBgYCBmaWVsZCBzZXQgdG8gdGhlIHNh bWUgdmFsdWUgd2hlbiBkZXF1ZXVlZC4KKworICAgSW4gYWRkaXRpb24gdG8gdGhlIHN0cmFpZ2h0 Zm9yd2FyZCBjYXNlIG9mIG9uZSBgYE9VVFBVVGBgIGJ1ZmZlciBwcm9kdWNpbmcKKyAgIG9uZSBg YENBUFRVUkVgYCBidWZmZXIsIHRoZSBmb2xsb3dpbmcgY2FzZXMgYXJlIGRlZmluZWQ6CisKKyAg ICogb25lIGBgT1VUUFVUYGAgYnVmZmVyIGdlbmVyYXRlcyBtdWx0aXBsZSBgYENBUFRVUkVgYCBi dWZmZXJzOiB0aGUgc2FtZQorICAgICBgYE9VVFBVVGBgIHRpbWVzdGFtcCB3aWxsIGJlIGNvcGll ZCB0byBtdWx0aXBsZSBgYENBUFRVUkVgYCBidWZmZXJzLAorCisgICAqIHRoZSBlbmNvZGluZyBv cmRlciBkaWZmZXJzIGZyb20gdGhlIHByZXNlbnRhdGlvbiBvcmRlciAoaS5lLiB0aGUKKyAgICAg YGBDQVBUVVJFYGAgYnVmZmVycyBhcmUgb3V0LW9mLW9yZGVyIGNvbXBhcmVkIHRvIHRoZSBgYE9V VFBVVGBgIGJ1ZmZlcnMpOgorICAgICBgYENBUFRVUkVgYCB0aW1lc3RhbXBzIHdpbGwgbm90IHJl dGFpbiB0aGUgb3JkZXIgb2YgYGBPVVRQVVRgYCB0aW1lc3RhbXBzLgorCisuLiBub3RlOjoKKwor ICAgVG8gbGV0IHRoZSBjbGllbnQgZGlzdGluZ3Vpc2ggYmV0d2VlbiBmcmFtZSB0eXBlcyAoa2V5 ZnJhbWVzLCBpbnRlcm1lZGlhdGUKKyAgIGZyYW1lczsgdGhlIGV4YWN0IGxpc3Qgb2YgdHlwZXMg ZGVwZW5kcyBvbiB0aGUgY29kZWQgZm9ybWF0KSwgdGhlCisgICBgYENBUFRVUkVgYCBidWZmZXJz IHdpbGwgaGF2ZSBjb3JyZXNwb25kaW5nIGZsYWcgYml0cyBzZXQgaW4gdGhlaXIKKyAgIDpjOnR5 cGU6YHY0bDJfYnVmZmVyYCBzdHJ1Y3Qgd2hlbiBkZXF1ZXVlZC4gU2VlIHRoZSBkb2N1bWVudGF0 aW9uIG9mCisgICA6Yzp0eXBlOmB2NGwyX2J1ZmZlcmAgYW5kIGVhY2ggY29kZWQgcGl4ZWwgZm9y bWF0IGZvciBleGFjdCBsaXN0IG9mIGZsYWdzCisgICBhbmQgdGhlaXIgbWVhbmluZ3MuCisKK1No b3VsZCBhbiBlbmNvZGluZyBlcnJvciBvY2N1ciwgaXQgd2lsbCBiZSByZXBvcnRlZCB0byB0aGUg Y2xpZW50IHdpdGggdGhlIGxldmVsCitvZiBkZXRhaWxzIGRlcGVuZGluZyBvbiB0aGUgZW5jb2Rl ciBjYXBhYmlsaXRpZXMuIFNwZWNpZmljYWxseToKKworKiB0aGUgQ0FQVFVSRSBidWZmZXIgKGlm IGFueSkgdGhhdCBjb250YWlucyB0aGUgcmVzdWx0cyBvZiB0aGUgZmFpbGVkIGVuY29kZQorICBv cGVyYXRpb24gd2lsbCBiZSByZXR1cm5lZCB3aXRoIHRoZSBWNEwyX0JVRl9GTEFHX0VSUk9SIGZs YWcgc2V0LAorCisqIGlmIHRoZSBlbmNvZGVyIGlzIGFibGUgdG8gcHJlY2lzZWx5IHJlcG9ydCB0 aGUgT1VUUFVUIGJ1ZmZlcihzKSB0aGF0IHRyaWdnZXJlZAorICB0aGUgZXJyb3IsIHN1Y2ggYnVm ZmVyKHMpIHdpbGwgYmUgcmV0dXJuZWQgd2l0aCB0aGUgVjRMMl9CVUZfRkxBR19FUlJPUiBmbGFn CisgIHNldC4KKworSW4gY2FzZSBvZiBhIGZhdGFsIGZhaWx1cmUgdGhhdCBkb2VzIG5vdCBhbGxv dyB0aGUgZW5jb2RpbmcgdG8gY29udGludWUsIGFueQorZnVydGhlciBvcGVyYXRpb25zIG9uIGNv cnJlc3BvbmRpbmcgZW5jb2RlciBmaWxlIGhhbmRsZSB3aWxsIHJldHVybiB0aGUgLUVJTworZXJy b3IgY29kZS4gVGhlIGNsaWVudCBtYXkgY2xvc2UgdGhlIGZpbGUgaGFuZGxlIGFuZCBvcGVuIGEg bmV3IG9uZSwgb3IKK2FsdGVybmF0aXZlbHkgcmVpbml0aWFsaXplIHRoZSBpbnN0YW5jZSBieSBz dG9wcGluZyBzdHJlYW1pbmcgb24gYm90aCBxdWV1ZXMsCityZWxlYXNpbmcgYWxsIGJ1ZmZlcnMg YW5kIHBlcmZvcm1pbmcgdGhlIEluaXRpYWxpemF0aW9uIHNlcXVlbmNlIGFnYWluLgorCitFbmNv ZGluZyBQYXJhbWV0ZXIgQ2hhbmdlcworPT09PT09PT09PT09PT09PT09PT09PT09PT0KKworVGhl IGNsaWVudCBpcyBhbGxvd2VkIHRvIHVzZSA6YzpmdW5jOmBWSURJT0NfU19DVFJMYCB0byBjaGFu Z2UgZW5jb2RlcgorcGFyYW1ldGVycyBhdCBhbnkgdGltZS4gVGhlIGF2YWlsYWJpbGl0eSBvZiBw YXJhbWV0ZXJzIGlzIGVuY29kZXItc3BlY2lmaWMKK2FuZCB0aGUgY2xpZW50IG11c3QgcXVlcnkg dGhlIGVuY29kZXIgdG8gZmluZCB0aGUgc2V0IG9mIGF2YWlsYWJsZSBjb250cm9scy4KKworVGhl IGFiaWxpdHkgdG8gY2hhbmdlIGVhY2ggcGFyYW1ldGVyIGR1cmluZyBlbmNvZGluZyBpcyBlbmNv ZGVyLXNwZWNpZmljLCBhcworcGVyIHRoZSBzdGFuZGFyZCBzZW1hbnRpY3Mgb2YgdGhlIFY0TDIg Y29udHJvbCBpbnRlcmZhY2UuIFRoZSBjbGllbnQgbWF5CithdHRlbXB0IHRvIHNldCBhIGNvbnRy b2wgZHVyaW5nIGVuY29kaW5nIGFuZCBpZiB0aGUgb3BlcmF0aW9uIGZhaWxzIHdpdGggdGhlCist RUJVU1kgZXJyb3IgY29kZSwgdGhlIGBgQ0FQVFVSRWBgIHF1ZXVlIG5lZWRzIHRvIGJlIHN0b3Bw ZWQgZm9yIHRoZQorY29uZmlndXJhdGlvbiBjaGFuZ2UgdG8gYmUgYWxsb3dlZC4gVG8gZG8gdGhp cywgaXQgbWF5IGZvbGxvdyB0aGUgYERyYWluYAorc2VxdWVuY2UgdG8gYXZvaWQgbG9zaW5nIHRo ZSBhbHJlYWR5IHF1ZXVlZC9lbmNvZGVkIGZyYW1lcy4KKworVGhlIHRpbWluZyBvZiBwYXJhbWV0 ZXIgdXBkYXRlcyBpcyBlbmNvZGVyLXNwZWNpZmljLCBhcyBwZXIgdGhlIHN0YW5kYXJkCitzZW1h bnRpY3Mgb2YgdGhlIFY0TDIgY29udHJvbCBpbnRlcmZhY2UuIElmIHRoZSBjbGllbnQgbmVlZHMg dG8gYXBwbHkgdGhlCitwYXJhbWV0ZXJzIGV4YWN0bHkgYXQgc3BlY2lmaWMgZnJhbWUsIHVzaW5n IHRoZSBSZXF1ZXN0IEFQSQorKDpyZWY6YG1lZGlhLXJlcXVlc3QtYXBpYCkgc2hvdWxkIGJlIGNv bnNpZGVyZWQsIGlmIHN1cHBvcnRlZCBieSB0aGUgZW5jb2Rlci4KKworRHJhaW4KKz09PT09CisK K1RvIGVuc3VyZSB0aGF0IGFsbCB0aGUgcXVldWVkIGBgT1VUUFVUYGAgYnVmZmVycyBoYXZlIGJl ZW4gcHJvY2Vzc2VkIGFuZCB0aGUKK3JlbGF0ZWQgYGBDQVBUVVJFYGAgYnVmZmVycyBhcmUgZ2l2 ZW4gdG8gdGhlIGNsaWVudCwgdGhlIGNsaWVudCBtdXN0IGZvbGxvdyB0aGUKK2RyYWluIHNlcXVl bmNlIGRlc2NyaWJlZCBiZWxvdy4gQWZ0ZXIgdGhlIGRyYWluIHNlcXVlbmNlIGVuZHMsIHRoZSBj bGllbnQgaGFzCityZWNlaXZlZCBhbGwgZW5jb2RlZCBmcmFtZXMgZm9yIGFsbCBgYE9VVFBVVGBg IGJ1ZmZlcnMgcXVldWVkIGJlZm9yZSB0aGUKK3NlcXVlbmNlIHdhcyBzdGFydGVkLgorCisxLiBC ZWdpbiB0aGUgZHJhaW4gc2VxdWVuY2UgYnkgaXNzdWluZyA6YzpmdW5jOmBWSURJT0NfRU5DT0RF Ul9DTURgLgorCisgICAqICoqUmVxdWlyZWQgZmllbGRzOioqCisKKyAgICAgYGBjbWRgYAorICAg ICAgICAgc2V0IHRvIGBgVjRMMl9FTkNfQ01EX1NUT1BgYC4KKworICAgICBgYGZsYWdzYGAKKyAg ICAgICAgIHNldCB0byAwLgorCisgICAgIGBgcHRzYGAKKyAgICAgICAgIHNldCB0byAwLgorCisg ICAuLiB3YXJuaW5nOjoKKworICAgICAgVGhlIHNlcXVlbmNlIGNhbiBiZSBvbmx5IGluaXRpYXRl ZCBpZiBib3RoIGBgT1VUUFVUYGAgYW5kIGBgQ0FQVFVSRWBgCisgICAgICBxdWV1ZXMgYXJlIHN0 cmVhbWluZy4gRm9yIGNvbXBhdGliaWxpdHkgcmVhc29ucywgdGhlIGNhbGwgdG8KKyAgICAgIDpj OmZ1bmM6YFZJRElPQ19FTkNPREVSX0NNRGAgd2lsbCBub3QgZmFpbCBldmVuIGlmIGFueSBvZiB0 aGUgcXVldWVzIGlzCisgICAgICBub3Qgc3RyZWFtaW5nLCBidXQgYXQgdGhlIHNhbWUgdGltZSBp dCB3aWxsIG5vdCBpbml0aWF0ZSB0aGUgYERyYWluYAorICAgICAgc2VxdWVuY2UgYW5kIHNvIHRo ZSBzdGVwcyBkZXNjcmliZWQgYmVsb3cgd291bGQgbm90IGJlIGFwcGxpY2FibGUuCisKKzIuIEFu eSBgYE9VVFBVVGBgIGJ1ZmZlcnMgcXVldWVkIGJ5IHRoZSBjbGllbnQgYmVmb3JlIHRoZQorICAg OmM6ZnVuYzpgVklESU9DX0VOQ09ERVJfQ01EYCB3YXMgaXNzdWVkIHdpbGwgYmUgcHJvY2Vzc2Vk IGFuZCBlbmNvZGVkIGFzCisgICBub3JtYWwuIFRoZSBjbGllbnQgbXVzdCBjb250aW51ZSB0byBo YW5kbGUgYm90aCBxdWV1ZXMgaW5kZXBlbmRlbnRseSwKKyAgIHNpbWlsYXJseSB0byBub3JtYWwg ZW5jb2RlIG9wZXJhdGlvbi4gVGhpcyBpbmNsdWRlczoKKworICAgKiBxdWV1aW5nIGFuZCBkZXF1 ZXVpbmcgYGBDQVBUVVJFYGAgYnVmZmVycywgdW50aWwgYSBidWZmZXIgbWFya2VkIHdpdGggdGhl CisgICAgIGBgVjRMMl9CVUZfRkxBR19MQVNUYGAgZmxhZyBpcyBkZXF1ZXVlZCwKKworICAgICAu LiB3YXJuaW5nOjoKKworICAgICAgICBUaGUgbGFzdCBidWZmZXIgbWF5IGJlIGVtcHR5ICh3aXRo IDpjOnR5cGU6YHY0bDJfYnVmZmVyYAorICAgICAgICBgYGJ5dGVzdXNlZGBgID0gMCkgYW5kIGlu IHRoYXQgY2FzZSBpdCBtdXN0IGJlIGlnbm9yZWQgYnkgdGhlIGNsaWVudCwKKyAgICAgICAgYXMg aXQgZG9lcyBub3QgY29udGFpbiBhbiBlbmNvZGVkIGZyYW1lLgorCisgICAgIC4uIG5vdGU6Ogor CisgICAgICAgIEFueSBhdHRlbXB0IHRvIGRlcXVldWUgbW9yZSBgYENBUFRVUkVgYCBidWZmZXJz IGJleW9uZCB0aGUgYnVmZmVyCisgICAgICAgIG1hcmtlZCB3aXRoIGBgVjRMMl9CVUZfRkxBR19M QVNUYGAgd2lsbCByZXN1bHQgaW4gYSAtRVBJUEUgZXJyb3IgZnJvbQorICAgICAgICA6YzpmdW5j OmBWSURJT0NfRFFCVUZgLgorCisgICAqIGRlcXVldWluZyBwcm9jZXNzZWQgYGBPVVRQVVRgYCBi dWZmZXJzLCB1bnRpbCBhbGwgdGhlIGJ1ZmZlcnMgcXVldWVkCisgICAgIGJlZm9yZSB0aGUgYGBW NEwyX0VOQ19DTURfU1RPUGBgIGNvbW1hbmQgYXJlIGRlcXVldWVkLAorCisgICAqIGRlcXVldWlu ZyB0aGUgYGBWNEwyX0VWRU5UX0VPU2BgIGV2ZW50LCBpZiB0aGUgY2xpZW50IHN1YnNjcmliZXMg dG8gaXQuCisKKyAgIC4uIG5vdGU6OgorCisgICAgICBGb3IgYmFja3dhcmRzIGNvbXBhdGliaWxp dHksIHRoZSBlbmNvZGVyIHdpbGwgc2lnbmFsIGEgYGBWNEwyX0VWRU5UX0VPU2BgCisgICAgICBl dmVudCB3aGVuIHRoZSBsYXN0IGZyYW1lIGhhcyBiZWVuIGVuY29kZWQgYW5kIGFsbCBmcmFtZXMg YXJlIHJlYWR5IHRvIGJlCisgICAgICBkZXF1ZXVlZC4gSXQgaXMgZGVwcmVjYXRlZCBiZWhhdmlv ciBhbmQgdGhlIGNsaWVudCBtdXN0IG5vdCByZWx5IG9uIGl0LgorICAgICAgVGhlIGBgVjRMMl9C VUZfRkxBR19MQVNUYGAgYnVmZmVyIGZsYWcgc2hvdWxkIGJlIHVzZWQgaW5zdGVhZC4KKworMy4g T25jZSBhbGwgYGBPVVRQVVRgYCBidWZmZXJzIHF1ZXVlZCBiZWZvcmUgdGhlIGBgVjRMMl9FTkNf Q01EX1NUT1BgYCBjYWxsIGFyZQorICAgZGVxdWV1ZWQgYW5kIHRoZSBsYXN0IGBgQ0FQVFVSRWBg IGJ1ZmZlciBpcyBkZXF1ZXVlZCwgdGhlIGVuY29kZXIgaXMgc3RvcHBlZAorICAgYW5kIGl0IHdp bGwgYWNjZXB0LCBidXQgbm90IHByb2Nlc3MgYW55IG5ld2x5IHF1ZXVlZCBgYE9VVFBVVGBgIGJ1 ZmZlcnMKKyAgIHVudGlsIHRoZSBjbGllbnQgaXNzdWVzIGFueSBvZiB0aGUgZm9sbG93aW5nIG9w ZXJhdGlvbnM6CisKKyAgICogYGBWNEwyX0VOQ19DTURfU1RBUlRgYCAtIHRoZSBlbmNvZGVyIHdp bGwgbm90IGJlIHJlc2V0IGFuZCB3aWxsIHJlc3VtZQorICAgICBvcGVyYXRpb24gbm9ybWFsbHks IHdpdGggYWxsIHRoZSBzdGF0ZSBmcm9tIGJlZm9yZSB0aGUgZHJhaW4sCisKKyAgICogYSBwYWly IG9mIDpjOmZ1bmM6YFZJRElPQ19TVFJFQU1PRkZgIGFuZCA6YzpmdW5jOmBWSURJT0NfU1RSRUFN T05gIG9uIHRoZQorICAgICBgYENBUFRVUkVgYCBxdWV1ZSAtIHRoZSBlbmNvZGVyIHdpbGwgYmUg cmVzZXQgKHNlZSB0aGUgYFJlc2V0YCBzZXF1ZW5jZSkKKyAgICAgYW5kIHRoZW4gcmVzdW1lIGVu Y29kaW5nLAorCisgICAqIGEgcGFpciBvZiA6YzpmdW5jOmBWSURJT0NfU1RSRUFNT0ZGYCBhbmQg OmM6ZnVuYzpgVklESU9DX1NUUkVBTU9OYCBvbiB0aGUKKyAgICAgYGBPVVRQVVRgYCBxdWV1ZSAt IHRoZSBlbmNvZGVyIHdpbGwgcmVzdW1lIG9wZXJhdGlvbiBub3JtYWxseSwgaG93ZXZlciBhbnkK KyAgICAgc291cmNlIGZyYW1lcyBxdWV1ZWQgdG8gdGhlIGBgT1VUUFVUYGAgcXVldWUgYmV0d2Vl biBgYFY0TDJfRU5DX0NNRF9TVE9QYGAKKyAgICAgYW5kIDpjOmZ1bmM6YFZJRElPQ19TVFJFQU1P RkZgIHdpbGwgYmUgZGlzY2FyZGVkLgorCisuLiBub3RlOjoKKworICAgT25jZSB0aGUgZHJhaW4g c2VxdWVuY2UgaXMgaW5pdGlhdGVkLCB0aGUgY2xpZW50IG5lZWRzIHRvIGRyaXZlIGl0IHRvCisg ICBjb21wbGV0aW9uLCBhcyBkZXNjcmliZWQgYnkgdGhlIHN0ZXBzIGFib3ZlLCB1bmxlc3MgaXQg YWJvcnRzIHRoZSBwcm9jZXNzIGJ5CisgICBpc3N1aW5nIDpjOmZ1bmM6YFZJRElPQ19TVFJFQU1P RkZgIG9uIGFueSBvZiB0aGUgYGBPVVRQVVRgYCBvciBgYENBUFRVUkVgYAorICAgcXVldWVzLiAg VGhlIGNsaWVudCBpcyBub3QgYWxsb3dlZCB0byBpc3N1ZSBgYFY0TDJfRU5DX0NNRF9TVEFSVGBg IG9yCisgICBgYFY0TDJfRU5DX0NNRF9TVE9QYGAgYWdhaW4gd2hpbGUgdGhlIGRyYWluIHNlcXVl bmNlIGlzIGluIHByb2dyZXNzIGFuZCB0aGV5CisgICB3aWxsIGZhaWwgd2l0aCAtRUJVU1kgZXJy b3IgY29kZSBpZiBhdHRlbXB0ZWQuCisKKyAgIEZvciByZWZlcmVuY2UsIGhhbmRsaW5nIG9mIHZh cmlvdXMgY29ybmVyIGNhc2VzIGlzIGRlc2NyaWJlZCBiZWxvdzoKKworICAgKiBJbiBjYXNlIG9m IG5vIGJ1ZmZlciBpbiB0aGUgYGBPVVRQVVRgYCBxdWV1ZSBhdCB0aGUgdGltZSB0aGUKKyAgICAg YGBWNEwyX0VOQ19DTURfU1RPUGBgIGNvbW1hbmQgd2FzIGlzc3VlZCwgdGhlIGRyYWluIHNlcXVl bmNlIGNvbXBsZXRlcworICAgICBpbW1lZGlhdGVseSBhbmQgdGhlIGVuY29kZXIgcmV0dXJucyBh biBlbXB0eSBgYENBUFRVUkVgYCBidWZmZXIgd2l0aCB0aGUKKyAgICAgYGBWNEwyX0JVRl9GTEFH X0xBU1RgYCBmbGFnIHNldC4KKworICAgKiBJbiBjYXNlIG9mIG5vIGJ1ZmZlciBpbiB0aGUgYGBD QVBUVVJFYGAgcXVldWUgYXQgdGhlIHRpbWUgdGhlIGRyYWluCisgICAgIHNlcXVlbmNlIGNvbXBs ZXRlcywgdGhlIG5leHQgdGltZSB0aGUgY2xpZW50IHF1ZXVlcyBhIGBgQ0FQVFVSRWBgIGJ1ZmZl cgorICAgICBpdCBpcyByZXR1cm5lZCBhdCBvbmNlIGFzIGFuIGVtcHR5IGJ1ZmZlciB3aXRoIHRo ZSBgYFY0TDJfQlVGX0ZMQUdfTEFTVGBgCisgICAgIGZsYWcgc2V0LgorCisgICAqIElmIDpjOmZ1 bmM6YFZJRElPQ19TVFJFQU1PRkZgIGlzIGNhbGxlZCBvbiB0aGUgYGBDQVBUVVJFYGAgcXVldWUg aW4gdGhlCisgICAgIG1pZGRsZSBvZiB0aGUgZHJhaW4gc2VxdWVuY2UsIHRoZSBkcmFpbiBzZXF1 ZW5jZSBpcyBjYW5jZWxlZCBhbmQgYWxsCisgICAgIGBgQ0FQVFVSRWBgIGJ1ZmZlcnMgYXJlIGlt cGxpY2l0bHkgcmV0dXJuZWQgdG8gdGhlIGNsaWVudC4KKworICAgKiBJZiA6YzpmdW5jOmBWSURJ T0NfU1RSRUFNT0ZGYCBpcyBjYWxsZWQgb24gdGhlIGBgT1VUUFVUYGAgcXVldWUgaW4gdGhlCisg ICAgIG1pZGRsZSBvZiB0aGUgZHJhaW4gc2VxdWVuY2UsIHRoZSBkcmFpbiBzZXF1ZW5jZSBjb21w bGV0ZXMgaW1tZWRpYXRlbHkgYW5kCisgICAgIG5leHQgYGBDQVBUVVJFYGAgYnVmZmVyIHdpbGwg YmUgcmV0dXJuZWQgZW1wdHkgd2l0aCB0aGUKKyAgICAgYGBWNEwyX0JVRl9GTEFHX0xBU1RgYCBm bGFnIHNldC4KKworICAgQWx0aG91Z2ggbWFuZGF0b3J5LCB0aGUgYXZhaWxhYmlsaXR5IG9mIGVu Y29kZXIgY29tbWFuZHMgbWF5IGJlIHF1ZXJpZWQKKyAgIHVzaW5nIDpjOmZ1bmM6YFZJRElPQ19U UllfRU5DT0RFUl9DTURgLgorCitSZXNldAorPT09PT0KKworVGhlIGNsaWVudCBtYXkgd2FudCB0 byByZXF1ZXN0IHRoZSBlbmNvZGVyIHRvIHJlaW5pdGlhbGl6ZSB0aGUgZW5jb2RpbmcsIHNvCit0 aGF0IHRoZSBmb2xsb3dpbmcgc3RyZWFtIGRhdGEgYmVjb21lcyBpbmRlcGVuZGVudCBmcm9tIHRo ZSBzdHJlYW0gZGF0YQorZ2VuZXJhdGVkIGJlZm9yZS4gRGVwZW5kaW5nIG9uIHRoZSBjb2RlZCBm b3JtYXQsIHRoYXQgbWF5IGltcGx5IHRoYXQ6CisKKyogZW5jb2RlZCBmcmFtZXMgcHJvZHVjZWQg YWZ0ZXIgdGhlIHJlc3RhcnQgbXVzdCBub3QgcmVmZXJlbmNlIGFueSBmcmFtZXMKKyAgcHJvZHVj ZWQgYmVmb3JlIHRoZSBzdG9wLCBlLmcuIG5vIGxvbmcgdGVybSByZWZlcmVuY2VzIGZvciBILjI2 NC9IRVZDLAorCisqIGFueSBoZWFkZXJzIHRoYXQgbXVzdCBiZSBpbmNsdWRlZCBpbiBhIHN0YW5k YWxvbmUgc3RyZWFtIG11c3QgYmUgcHJvZHVjZWQKKyAgYWdhaW4sIGUuZy4gU1BTIGFuZCBQUFMg Zm9yIEguMjY0L0hFVkMuCisKK1RoaXMgY2FuIGJlIGFjaGlldmVkIGJ5IHBlcmZvcm1pbmcgdGhl IHJlc2V0IHNlcXVlbmNlLgorCisxLiBQZXJmb3JtIHRoZSBgRHJhaW5gIHNlcXVlbmNlIHRvIGVu c3VyZSBhbGwgdGhlIGluLWZsaWdodCBlbmNvZGluZyBmaW5pc2hlcworICAgYW5kIHJlc3BlY3Rp dmUgYnVmZmVycyBhcmUgZGVxdWV1ZWQuCisKKzIuIFN0b3Agc3RyZWFtaW5nIG9uIHRoZSBgYENB UFRVUkVgYCBxdWV1ZSB2aWEgOmM6ZnVuYzpgVklESU9DX1NUUkVBTU9GRmAuIFRoaXMKKyAgIHdp bGwgcmV0dXJuIGFsbCBjdXJyZW50bHkgcXVldWVkIGBgQ0FQVFVSRWBgIGJ1ZmZlcnMgdG8gdGhl IGNsaWVudCwgd2l0aG91dAorICAgdmFsaWQgZnJhbWUgZGF0YS4KKworMy4gU3RhcnQgc3RyZWFt aW5nIG9uIHRoZSBgYENBUFRVUkVgYCBxdWV1ZSB2aWEgOmM6ZnVuYzpgVklESU9DX1NUUkVBTU9O YCBhbmQKKyAgIGNvbnRpbnVlIHdpdGggcmVndWxhciBlbmNvZGluZyBzZXF1ZW5jZS4gVGhlIGVu Y29kZWQgZnJhbWVzIHByb2R1Y2VkIGludG8KKyAgIGBgQ0FQVFVSRWBgIGJ1ZmZlcnMgZnJvbSBu b3cgb24gd2lsbCBjb250YWluIGEgc3RhbmRhbG9uZSBzdHJlYW0gdGhhdCBjYW4gYmUKKyAgIGRl Y29kZWQgd2l0aG91dCB0aGUgbmVlZCBmb3IgZnJhbWVzIGVuY29kZWQgYmVmb3JlIHRoZSByZXNl dCBzZXF1ZW5jZSwKKyAgIHN0YXJ0aW5nIGF0IHRoZSBmaXJzdCBgYE9VVFBVVGBgIGJ1ZmZlciBx dWV1ZWQgYWZ0ZXIgaXNzdWluZyB0aGUKKyAgIGBWNEwyX0VOQ19DTURfU1RPUGAgb2YgdGhlIGBE cmFpbmAgc2VxdWVuY2UuCisKK1RoaXMgc2VxdWVuY2UgbWF5IGJlIGFsc28gdXNlZCB0byBjaGFu Z2UgZW5jb2RpbmcgcGFyYW1ldGVycyBmb3IgZW5jb2RlcnMKK3dpdGhvdXQgdGhlIGFiaWxpdHkg dG8gY2hhbmdlIHRoZSBwYXJhbWV0ZXJzIG9uIHRoZSBmbHkuCisKK0NvbW1pdCBQb2ludHMKKz09 PT09PT09PT09PT0KKworU2V0dGluZyBmb3JtYXRzIGFuZCBhbGxvY2F0aW5nIGJ1ZmZlcnMgdHJp Z2dlcnMgY2hhbmdlcyBpbiB0aGUgYmVoYXZpb3Igb2YgdGhlCitlbmNvZGVyLgorCisxLiBTZXR0 aW5nIHRoZSBmb3JtYXQgb24gdGhlIGBgQ0FQVFVSRWBgIHF1ZXVlIG1heSBjaGFuZ2UgdGhlIHNl dCBvZiBmb3JtYXRzCisgICBzdXBwb3J0ZWQvYWR2ZXJ0aXNlZCBvbiB0aGUgYGBPVVRQVVRgYCBx dWV1ZS4gSW4gcGFydGljdWxhciwgaXQgYWxzbyBtZWFucworICAgdGhhdCB0aGUgYGBPVVRQVVRg YCBmb3JtYXQgbWF5IGJlIHJlc2V0IGFuZCB0aGUgY2xpZW50IG11c3Qgbm90IHJlbHkgb24gdGhl CisgICBwcmV2aW91c2x5IHNldCBmb3JtYXQgYmVpbmcgcHJlc2VydmVkLgorCisyLiBFbnVtZXJh dGluZyBmb3JtYXRzIG9uIHRoZSBgYE9VVFBVVGBgIHF1ZXVlIGFsd2F5cyByZXR1cm5zIG9ubHkg Zm9ybWF0cworICAgc3VwcG9ydGVkIGZvciB0aGUgY3VycmVudCBgYENBUFRVUkVgYCBmb3JtYXQu CisKKzMuIFNldHRpbmcgdGhlIGZvcm1hdCBvbiB0aGUgYGBPVVRQVVRgYCBxdWV1ZSBkb2VzIG5v dCBjaGFuZ2UgdGhlIGxpc3Qgb2YKKyAgIGZvcm1hdHMgYXZhaWxhYmxlIG9uIHRoZSBgYENBUFRV UkVgYCBxdWV1ZS4gQW4gYXR0ZW1wdCB0byBzZXQgdGhlIGBgT1VUUFVUYGAKKyAgIGZvcm1hdCB0 aGF0IGlzIG5vdCBzdXBwb3J0ZWQgZm9yIHRoZSBjdXJyZW50bHkgc2VsZWN0ZWQgYGBDQVBUVVJF YGAgZm9ybWF0CisgICB3aWxsIHJlc3VsdCBpbiB0aGUgZW5jb2RlciBhZGp1c3RpbmcgdGhlIHJl cXVlc3RlZCBgYE9VVFBVVGBgIGZvcm1hdCB0byBhCisgICBzdXBwb3J0ZWQgb25lLgorCis0LiBF bnVtZXJhdGluZyBmb3JtYXRzIG9uIHRoZSBgYENBUFRVUkVgYCBxdWV1ZSBhbHdheXMgcmV0dXJu cyB0aGUgZnVsbCBzZXQgb2YKKyAgIHN1cHBvcnRlZCBjb2RlZCBmb3JtYXRzLCBpcnJlc3BlY3Rp dmUgb2YgdGhlIGN1cnJlbnQgYGBPVVRQVVRgYCBmb3JtYXQuCisKKzUuIFdoaWxlIGJ1ZmZlcnMg YXJlIGFsbG9jYXRlZCBvbiBhbnkgb2YgdGhlIGBgT1VUUFVUYGAgb3IgYGBDQVBUVVJFYGAgcXVl dWVzLAorICAgdGhlIGNsaWVudCBtdXN0IG5vdCBjaGFuZ2UgdGhlIGZvcm1hdCBvbiB0aGUgYGBD QVBUVVJFYGAgcXVldWUuIERyaXZlcnMgd2lsbAorICAgcmV0dXJuIHRoZSAtRUJVU1kgZXJyb3Ig Y29kZSBmb3IgYW55IHN1Y2ggZm9ybWF0IGNoYW5nZSBhdHRlbXB0LgorCitUbyBzdW1tYXJpemUs IHNldHRpbmcgZm9ybWF0cyBhbmQgYWxsb2NhdGlvbiBtdXN0IGFsd2F5cyBzdGFydCB3aXRoIHRo ZQorYGBDQVBUVVJFYGAgcXVldWUgYW5kIHRoZSBgYENBUFRVUkVgYCBxdWV1ZSBpcyB0aGUgbWFz dGVyIHRoYXQgZ292ZXJucyB0aGUKK3NldCBvZiBzdXBwb3J0ZWQgZm9ybWF0cyBmb3IgdGhlIGBg T1VUUFVUYGAgcXVldWUuCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL21lZGlhL3VhcGkvdjRs L2Rldi1tZW0ybWVtLnJzdCBiL0RvY3VtZW50YXRpb24vbWVkaWEvdWFwaS92NGwvZGV2LW1lbTJt ZW0ucnN0CmluZGV4IDcwOTUzOTU4Y2VlNi4uNDNmMTRjY2I2NzVlIDEwMDY0NAotLS0gYS9Eb2N1 bWVudGF0aW9uL21lZGlhL3VhcGkvdjRsL2Rldi1tZW0ybWVtLnJzdAorKysgYi9Eb2N1bWVudGF0 aW9uL21lZGlhL3VhcGkvdjRsL2Rldi1tZW0ybWVtLnJzdApAQCAtNDYsNCArNDYsNSBAQCBkZXZp Y2VzIGFyZSBnaXZlbiBpbiB0aGUgZm9sbG93aW5nIHNlY3Rpb25zLgogICAgIDptYXhkZXB0aDog MQogCiAgICAgZGV2LWRlY29kZXIKKyAgICBkZXYtZW5jb2RlcgogICAgIGRldi1zdGF0ZWxlc3Mt ZGVjb2RlcgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9tZWRpYS91YXBpL3Y0bC9waXhmbXQt djRsMi5yc3QgYi9Eb2N1bWVudGF0aW9uL21lZGlhL3VhcGkvdjRsL3BpeGZtdC12NGwyLnJzdApp bmRleCBhODMyMWMzNDhiZjguLmI3Y2NjNjEzYTM4MiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlv bi9tZWRpYS91YXBpL3Y0bC9waXhmbXQtdjRsMi5yc3QKKysrIGIvRG9jdW1lbnRhdGlvbi9tZWRp YS91YXBpL3Y0bC9waXhmbXQtdjRsMi5yc3QKQEAgLTQ0LDYgKzQ0LDExIEBAIFNpbmdsZS1wbGFu YXIgZm9ybWF0IHN0cnVjdHVyZQogCWluc2lkZSB0aGUgc3RyZWFtLCB3aGVuIGZlZCB0byBhIHN0 YXRlZnVsIG1lbTJtZW0gZGVjb2RlciwgdGhlIGZpZWxkcwogCW1heSBiZSB6ZXJvIHRvIHJlbHkg b24gdGhlIGRlY29kZXIgdG8gZGV0ZWN0IHRoZSByaWdodCB2YWx1ZXMuIEZvciBtb3JlCiAJZGV0 YWlscyBzZWUgOnJlZjpgZGVjb2RlcmAgYW5kIGZvcm1hdCBkZXNjcmlwdGlvbnMuCisKKwlGb3Ig Y29tcHJlc3NlZCBmb3JtYXRzIG9uIHRoZSBDQVBUVVJFIHNpZGUgb2YgYSBzdGF0ZWZ1bCBtZW0y bWVtCisJZW5jb2RlciwgdGhlIGZpZWxkcyBtdXN0IGJlIHplcm8sIHNpbmNlIHRoZSBjb2RlZCBz aXplIGlzIGV4cGVjdGVkIHRvCisJYmUgY2FsY3VsYXRlZCBpbnRlcm5hbGx5IGJ5IHRoZSBlbmNv ZGVyIGl0c2VsZiwgYmFzZWQgb24gdGhlIE9VVFBVVAorCXNpZGUuIEZvciBtb3JlIGRldGFpbHMg c2VlIDpyZWY6YGVuY29kZXJgIGFuZCBmb3JtYXQgZGVzY3JpcHRpb25zLgogICAgICogLSBfX3Uz MgogICAgICAgLSBgYHBpeGVsZm9ybWF0YGAKICAgICAgIC0gVGhlIHBpeGVsIGZvcm1hdCBvciB0 eXBlIG9mIGNvbXByZXNzaW9uLCBzZXQgYnkgdGhlIGFwcGxpY2F0aW9uLgpkaWZmIC0tZ2l0IGEv RG9jdW1lbnRhdGlvbi9tZWRpYS91YXBpL3Y0bC92NGwyLnJzdCBiL0RvY3VtZW50YXRpb24vbWVk aWEvdWFwaS92NGwvdjRsMi5yc3QKaW5kZXggOTcwMTViOWI0MGI4Li5lMjM2ZWEyMzQ4MWIgMTAw NjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vbWVkaWEvdWFwaS92NGwvdjRsMi5yc3QKKysrIGIvRG9j dW1lbnRhdGlvbi9tZWRpYS91YXBpL3Y0bC92NGwyLnJzdApAQCAtNjMsNiArNjMsNyBAQCBBdXRo b3JzLCBpbiBhbHBoYWJldGljYWwgb3JkZXI6CiAtIEZpZ2EsIFRvbWFzeiA8dGZpZ2FAY2hyb21p dW0ub3JnPgogCiAgIC0gRG9jdW1lbnRlZCB0aGUgbWVtb3J5LXRvLW1lbW9yeSBkZWNvZGVyIGlu dGVyZmFjZS4KKyAgLSBEb2N1bWVudGVkIHRoZSBtZW1vcnktdG8tbWVtb3J5IGVuY29kZXIgaW50 ZXJmYWNlLgogCiAtIEggU2NoaW1laywgTWljaGFlbCA8bXNjaGltZWtAZ214LmF0PgogCkBAIC03 NSw2ICs3Niw3IEBAIEF1dGhvcnMsIGluIGFscGhhYmV0aWNhbCBvcmRlcjoKIC0gT3NjaWFrLCBQ YXdlbCA8cG9zY2lha0BjaHJvbWl1bS5vcmc+CiAKICAgLSBEb2N1bWVudGVkIHRoZSBtZW1vcnkt dG8tbWVtb3J5IGRlY29kZXIgaW50ZXJmYWNlLgorICAtIERvY3VtZW50ZWQgdGhlIG1lbW9yeS10 by1tZW1vcnkgZW5jb2RlciBpbnRlcmZhY2UuCiAKIC0gT3NjaWFrLCBQYXdlbCA8cGF3ZWxAb3Nj aWFrLmNvbT4KIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9tZWRpYS91YXBpL3Y0bC92aWRp b2MtZW5jb2Rlci1jbWQucnN0IGIvRG9jdW1lbnRhdGlvbi9tZWRpYS91YXBpL3Y0bC92aWRpb2Mt ZW5jb2Rlci1jbWQucnN0CmluZGV4IGMzMTNjYThiOGNiNS4uODgyODFlNzA3NDc2IDEwMDY0NAot LS0gYS9Eb2N1bWVudGF0aW9uL21lZGlhL3VhcGkvdjRsL3ZpZGlvYy1lbmNvZGVyLWNtZC5yc3QK KysrIGIvRG9jdW1lbnRhdGlvbi9tZWRpYS91YXBpL3Y0bC92aWRpb2MtZW5jb2Rlci1jbWQucnN0 CkBAIC01MSwyNSArNTEsMjYgQEAgVG8gc2VuZCBhIGNvbW1hbmQgYXBwbGljYXRpb25zIG11c3Qg aW5pdGlhbGl6ZSBhbGwgZmllbGRzIG9mIGEgc3RydWN0CiBgYFZJRElPQ19FTkNPREVSX0NNRGBg IG9yIGBgVklESU9DX1RSWV9FTkNPREVSX0NNRGBgIHdpdGggYSBwb2ludGVyIHRvCiB0aGlzIHN0 cnVjdHVyZS4KIAotVGhlIGBgY21kYGAgZmllbGQgbXVzdCBjb250YWluIHRoZSBjb21tYW5kIGNv ZGUuIFRoZSBgYGZsYWdzYGAgZmllbGQgaXMKLWN1cnJlbnRseSBvbmx5IHVzZWQgYnkgdGhlIFNU T1AgY29tbWFuZCBhbmQgY29udGFpbnMgb25lIGJpdDogSWYgdGhlCi1gYFY0TDJfRU5DX0NNRF9T VE9QX0FUX0dPUF9FTkRgYCBmbGFnIGlzIHNldCwgZW5jb2Rpbmcgd2lsbCBjb250aW51ZQotdW50 aWwgdGhlIGVuZCBvZiB0aGUgY3VycmVudCAqR3JvdXAgT2YgUGljdHVyZXMqLCBvdGhlcndpc2Ug aXQgd2lsbCBzdG9wCi1pbW1lZGlhdGVseS4KK1RoZSBgYGNtZGBgIGZpZWxkIG11c3QgY29udGFp biB0aGUgY29tbWFuZCBjb2RlLiBTb21lIGNvbW1hbmRzIHVzZSB0aGUKK2BgZmxhZ3NgYCBmaWVs ZCBmb3IgYWRkaXRpb25hbCBpbmZvcm1hdGlvbi4KIAotQSA6cmVmOmByZWFkKCkgPGZ1bmMtcmVh ZD5gIG9yIDpyZWY6YFZJRElPQ19TVFJFQU1PTiA8VklESU9DX1NUUkVBTU9OPmAKLWNhbGwgc2Vu ZHMgYW4gaW1wbGljaXQgU1RBUlQgY29tbWFuZCB0byB0aGUgZW5jb2RlciBpZiBpdCBoYXMgbm90 IGJlZW4KLXN0YXJ0ZWQgeWV0LiBBZnRlciBhIFNUT1AgY29tbWFuZCwgOnJlZjpgcmVhZCgpIDxm dW5jLXJlYWQ+YCBjYWxscyB3aWxsIHJlYWQKK0FmdGVyIGEgU1RPUCBjb21tYW5kLCA6cmVmOmBy ZWFkKCkgPGZ1bmMtcmVhZD5gIGNhbGxzIHdpbGwgcmVhZAogdGhlIHJlbWFpbmluZyBkYXRhIGJ1 ZmZlcmVkIGJ5IHRoZSBkcml2ZXIuIFdoZW4gdGhlIGJ1ZmZlciBpcyBlbXB0eSwKIDpyZWY6YHJl YWQoKSA8ZnVuYy1yZWFkPmAgd2lsbCByZXR1cm4gemVybyBhbmQgdGhlIG5leHQgOnJlZjpgcmVh ZCgpIDxmdW5jLXJlYWQ+YAogY2FsbCB3aWxsIHJlc3RhcnQgdGhlIGVuY29kZXIuCiAKK0EgOnJl ZjpgcmVhZCgpIDxmdW5jLXJlYWQ+YCBvciA6cmVmOmBWSURJT0NfU1RSRUFNT04gPFZJRElPQ19T VFJFQU1PTj5gCitjYWxsIHNlbmRzIGFuIGltcGxpY2l0IFNUQVJUIGNvbW1hbmQgdG8gdGhlIGVu Y29kZXIgaWYgaXQgaGFzIG5vdCBiZWVuCitzdGFydGVkIHlldC4gQXBwbGllcyB0byBib3RoIHF1 ZXVlcyBvZiBtZW0ybWVtIGVuY29kZXJzLgorCiBBIDpyZWY6YGNsb3NlKCkgPGZ1bmMtY2xvc2U+ YCBvciA6cmVmOmBWSURJT0NfU1RSRUFNT0ZGIDxWSURJT0NfU1RSRUFNT04+YAogY2FsbCBvZiBh IHN0cmVhbWluZyBmaWxlIGRlc2NyaXB0b3Igc2VuZHMgYW4gaW1wbGljaXQgaW1tZWRpYXRlIFNU T1AgdG8KLXRoZSBlbmNvZGVyLCBhbmQgYWxsIGJ1ZmZlcmVkIGRhdGEgaXMgZGlzY2FyZGVkLgor dGhlIGVuY29kZXIsIGFuZCBhbGwgYnVmZmVyZWQgZGF0YSBpcyBkaXNjYXJkZWQuIEFwcGxpZXMg dG8gYm90aCBxdWV1ZXMgb2YKK21lbTJtZW0gZW5jb2RlcnMuCiAKIFRoZXNlIGlvY3RscyBhcmUg b3B0aW9uYWwsIG5vdCBhbGwgZHJpdmVycyBtYXkgc3VwcG9ydCB0aGVtLiBUaGV5IHdlcmUKLWlu dHJvZHVjZWQgaW4gTGludXggMi42LjIxLgoraW50cm9kdWNlZCBpbiBMaW51eCAyLjYuMjEuIFRo ZXkgYXJlLCBob3dldmVyLCBtYW5kYXRvcnkgZm9yIHN0YXRlZnVsIG1lbTJtZW0KK2VuY29kZXJz IChhcyBmdXJ0aGVyIGRvY3VtZW50ZWQgaW4gOnJlZjpgZW5jb2RlcmApLgogCiAKIC4uIHRhYnVs YXJjb2x1bW5zOjogfHB7NC40Y219fHB7NC40Y219fHB7OC43Y219fApAQCAtMTA5LDIxICsxMTAs MjQgQEAgaW50cm9kdWNlZCBpbiBMaW51eCAyLjYuMjEuCiAgICAgICAtIDAKICAgICAgIC0gU3Rh cnQgdGhlIGVuY29kZXIuIFdoZW4gdGhlIGVuY29kZXIgaXMgYWxyZWFkeSBydW5uaW5nIG9yIHBh dXNlZCwKIAl0aGlzIGNvbW1hbmQgZG9lcyBub3RoaW5nLiBObyBmbGFncyBhcmUgZGVmaW5lZCBm b3IgdGhpcyBjb21tYW5kLgorCisJRm9yIGEgZGV2aWNlIGltcGxlbWVudGluZyB0aGUgOnJlZjpg ZW5jb2RlcmAsIG9uY2UgdGhlIGRyYWluIHNlcXVlbmNlCisJaXMgaW5pdGlhdGVkIHdpdGggdGhl IGBgVjRMMl9FTkNfQ01EX1NUT1BgYCBjb21tYW5kLCBpdCBtdXN0IGJlIGRyaXZlbgorCXRvIGNv bXBsZXRpb24gYmVmb3JlIHRoaXMgY29tbWFuZCBjYW4gYmUgaW52b2tlZC4gIEFueSBhdHRlbXB0 IHRvCisJaW52b2tlIHRoZSBjb21tYW5kIHdoaWxlIHRoZSBkcmFpbiBzZXF1ZW5jZSBpcyBpbiBw cm9ncmVzcyB3aWxsIHRyaWdnZXIKKwlhbiBgYEVCVVNZYGAgZXJyb3IgY29kZS4gU2VlIDpyZWY6 YGVuY29kZXJgIGZvciBtb3JlIGRldGFpbHMuCiAgICAgKiAtIGBgVjRMMl9FTkNfQ01EX1NUT1Bg YAogICAgICAgLSAxCiAgICAgICAtIFN0b3AgdGhlIGVuY29kZXIuIFdoZW4gdGhlIGBgVjRMMl9F TkNfQ01EX1NUT1BfQVRfR09QX0VORGBgIGZsYWcKIAlpcyBzZXQsIGVuY29kaW5nIHdpbGwgY29u dGludWUgdW50aWwgdGhlIGVuZCBvZiB0aGUgY3VycmVudCAqR3JvdXAKIAlPZiBQaWN0dXJlcyos IG90aGVyd2lzZSBlbmNvZGluZyB3aWxsIHN0b3AgaW1tZWRpYXRlbHkuIFdoZW4gdGhlCi0JZW5j b2RlciBpcyBhbHJlYWR5IHN0b3BwZWQsIHRoaXMgY29tbWFuZCBkb2VzIG5vdGhpbmcuIG1lbTJt ZW0KLQllbmNvZGVycyB3aWxsIHNlbmQgYSBgYFY0TDJfRVZFTlRfRU9TYGAgZXZlbnQgd2hlbiB0 aGUgbGFzdCBmcmFtZQotCWhhcyBiZWVuIGVuY29kZWQgYW5kIGFsbCBmcmFtZXMgYXJlIHJlYWR5 IHRvIGJlIGRlcXVldWVkIGFuZCB3aWxsCi0Jc2V0IHRoZSBgYFY0TDJfQlVGX0ZMQUdfTEFTVGBg IGJ1ZmZlciBmbGFnIG9uIHRoZSBsYXN0IGJ1ZmZlciBvZgotCXRoZSBjYXB0dXJlIHF1ZXVlIHRv IGluZGljYXRlIHRoZXJlIHdpbGwgYmUgbm8gbmV3IGJ1ZmZlcnMKLQlwcm9kdWNlZCB0byBkZXF1 ZXVlLiBUaGlzIGJ1ZmZlciBtYXkgYmUgZW1wdHksIGluZGljYXRlZCBieSB0aGUKLQlkcml2ZXIg c2V0dGluZyB0aGUgYGBieXRlc3VzZWRgYCBmaWVsZCB0byAwLiBPbmNlIHRoZQotCWBgVjRMMl9C VUZfRkxBR19MQVNUYGAgZmxhZyB3YXMgc2V0LCB0aGUKLQk6cmVmOmBWSURJT0NfRFFCVUYgPFZJ RElPQ19RQlVGPmAgaW9jdGwgd2lsbCBub3QgYmxvY2sgYW55bW9yZSwKLQlidXQgcmV0dXJuIGFu IGBgRVBJUEVgYCBlcnJvciBjb2RlLgorCWVuY29kZXIgaXMgYWxyZWFkeSBzdG9wcGVkLCB0aGlz IGNvbW1hbmQgZG9lcyBub3RoaW5nLgorCisJRm9yIGEgZGV2aWNlIGltcGxlbWVudGluZyB0aGUg OnJlZjpgZW5jb2RlcmAsIHRoZSBjb21tYW5kIHdpbGwgaW5pdGlhdGUKKwl0aGUgZHJhaW4gc2Vx dWVuY2UgYXMgZG9jdW1lbnRlZCBpbiA6cmVmOmBlbmNvZGVyYC4gTm8gZmxhZ3Mgb3Igb3RoZXIK Kwlhcmd1bWVudHMgYXJlIGFjY2VwdGVkIGluIHRoaXMgY2FzZS4gQW55IGF0dGVtcHQgdG8gaW52 b2tlIHRoZSBjb21tYW5kCisJYWdhaW4gYmVmb3JlIHRoZSBzZXF1ZW5jZSBjb21wbGV0ZXMgd2ls bCB0cmlnZ2VyIGFuIGBgRUJVU1lgYCBlcnJvcgorCWNvZGUuCiAgICAgKiAtIGBgVjRMMl9FTkNf Q01EX1BBVVNFYGAKICAgICAgIC0gMgogICAgICAgLSBQYXVzZSB0aGUgZW5jb2Rlci4gV2hlbiB0 aGUgZW5jb2RlciBoYXMgbm90IGJlZW4gc3RhcnRlZCB5ZXQsIHRoZQpAQCAtMTUyLDYgKzE1Niw4 IEBAIGludHJvZHVjZWQgaW4gTGludXggMi42LjIxLgogICAgICAgLSBTdG9wIGVuY29kaW5nIGF0 IHRoZSBlbmQgb2YgdGhlIGN1cnJlbnQgKkdyb3VwIE9mIFBpY3R1cmVzKiwKIAlyYXRoZXIgdGhh biBpbW1lZGlhdGVseS4KIAorICAgICAgICBEb2VzIG5vdCBhcHBseSB0byA6cmVmOmBlbmNvZGVy YC4KKwogCiBSZXR1cm4gVmFsdWUKID09PT09PT09PT09PQpAQCAtMTYwLDYgKzE2NiwxMSBAQCBP biBzdWNjZXNzIDAgaXMgcmV0dXJuZWQsIG9uIGVycm9yIC0xIGFuZCB0aGUgYGBlcnJub2BgIHZh cmlhYmxlIGlzIHNldAogYXBwcm9wcmlhdGVseS4gVGhlIGdlbmVyaWMgZXJyb3IgY29kZXMgYXJl IGRlc2NyaWJlZCBhdCB0aGUKIDpyZWY6YEdlbmVyaWMgRXJyb3IgQ29kZXMgPGdlbi1lcnJvcnM+ YCBjaGFwdGVyLgogCitFQlVTWQorICAgIEEgZHJhaW4gc2VxdWVuY2Ugb2YgYSBkZXZpY2UgaW1w bGVtZW50aW5nIHRoZSA6cmVmOmBlbmNvZGVyYCBpcyBzdGlsbCBpbgorICAgIHByb2dyZXNzLiBJ dCBpcyBub3QgYWxsb3dlZCB0byBpc3N1ZSBhbm90aGVyIGVuY29kZXIgY29tbWFuZCB1bnRpbCBp dAorICAgIGNvbXBsZXRlcy4KKwogRUlOVkFMCiAgICAgVGhlIGBgY21kYGAgZmllbGQgaXMgaW52 YWxpZC4KIAotLSAKMi4yMi4xCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KbGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5l bEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4v bGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo=