From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from perceval.ideasonboard.com ([213.167.242.64]:51288 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729547AbeHNMdr (ORCPT ); Tue, 14 Aug 2018 08:33:47 -0400 From: Laurent Pinchart To: Dmitry Osipenko Cc: Laurent Pinchart , Ville =?ISO-8859-1?Q?Syrj=E4l=E4?= , Thierry Reding , Neil Armstrong , Maxime Ripard , dri-devel@lists.freedesktop.org, Paul Kocialkowski , Russell King , Maarten Lankhorst , linux-media@vger.kernel.org, linux-renesas-soc@vger.kernel.org, Ben Skeggs , Sinclair Yeh , Thomas Hellstrom , Jani Nikula , Joonas Lahtinen , Rodrigo Vivi , linux-tegra@vger.kernel.org, linux-kernel@vger.kernel.org Subject: Re: [RFC PATCH v4 1/2] drm: Add generic colorkey properties for display planes Date: Tue, 14 Aug 2018 12:48:08 +0300 Message-ID: <7041537.TPdt8DIvGD@avalon> In-Reply-To: <20180807172202.1961-2-digetx@gmail.com> References: <20180807172202.1961-1-digetx@gmail.com> <20180807172202.1961-2-digetx@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" Sender: linux-renesas-soc-owner@vger.kernel.org List-ID: Hi Dmitry, Thank you for the patch. On Tuesday, 7 August 2018 20:22:01 EEST Dmitry Osipenko wrote: > From: Laurent Pinchart > > Color keying is the action of replacing pixels matching a given color > (or range of colors) with transparent pixels in an overlay when > performing blitting. Depending on the hardware capabilities, the > matching pixel can either become fully transparent or gain adjustment > of the pixels component values. > > Color keying is found in a large number of devices whose capabilities > often differ, but they still have enough common features in range to > standardize color key properties. This commit adds new generic DRM plane > properties related to the color keying, providing initial color keying > support. > > Signed-off-by: Laurent Pinchart > Signed-off-by: Dmitry Osipenko > --- > drivers/gpu/drm/drm_atomic.c | 20 +++++ > drivers/gpu/drm/drm_blend.c | 150 +++++++++++++++++++++++++++++++++++ > include/drm/drm_blend.h | 3 + > include/drm/drm_plane.h | 91 +++++++++++++++++++++ > 4 files changed, 264 insertions(+) [snip] > diff --git a/drivers/gpu/drm/drm_blend.c b/drivers/gpu/drm/drm_blend.c > index a16a74d7e15e..13c61dd0d9b7 100644 > --- a/drivers/gpu/drm/drm_blend.c > +++ b/drivers/gpu/drm/drm_blend.c > @@ -107,6 +107,11 @@ > * planes. Without this property the primary plane is always below the > cursor * plane, and ordering between all other planes is undefined. > * > + * colorkey: > + * Color keying is set up with drm_plane_create_colorkey_properties(). > + * It adds support for actions like replacing a range of colors with a > + * transparent color in the plane. Color keying is disabled by default. > + * > * Note that all the property extensions described here apply either to the > * plane or the CRTC (e.g. for the background color, which currently is not > * exposed and assumed to be black). > @@ -448,3 +453,148 @@ int drm_atomic_normalize_zpos(struct drm_device *dev, > return 0; > } > EXPORT_SYMBOL(drm_atomic_normalize_zpos); > + > +static const char * const plane_colorkey_mode_name[] = { > + [DRM_PLANE_COLORKEY_MODE_DISABLED] = "disabled", > + [DRM_PLANE_COLORKEY_MODE_TRANSPARENT] = "transparent", > +}; > + > +/** > + * drm_plane_create_colorkey_properties - create colorkey properties > + * @plane: drm plane > + * @supported_modes: bitmask of supported color keying modes > + * > + * This function creates the generic color keying properties and attaches > them > + * to the @plane to enable color keying control for blending operations. > + * > + * Glossary: > + * > + * Destination plane: > + * Plane to which color keying properties are applied, this planes takes > + * the effect of color keying operation. The effect is determined by a > + * given color keying mode. > + * > + * Source plane: > + * Pixels of this plane are the source for color key matching operation. > + * > + * Color keying is controlled by these properties: > + * > + * colorkey.plane_mask: > + * The mask property specifies which planes participate in color key > + * matching process, these planes are the color key sources. > + * > + * Drivers return an error from their plane atomic check if plane can't be > + * handled. This seems fragile to me. We don't document how userspace determines which planes need to be specified here, and we don't document what happens if a plane underneath the destination plane is not specified in the mask. More precise documentation is needed if we want to use such a property. It also seems quite complex. Is an explicit plane mask really the best option ? What's the reason why planes couldn't be handled ? How do drivers determine that ? > + * colorkey.mode: > + * The mode is an enumerated property that controls how color keying > + * operates. A link to the drm_plane_colorkey_mode enum documentation would be useful. > + * colorkey.mask: > + * This property specifies the pixel components mask. Unmasked pixel > + * components are not participating in the matching. This mask value is > + * applied to colorkey.min / max values. The mask value is given in a > + * 64-bit integer in ARGB16161616 format, where A is the alpha value and > + * R, G and B correspond to the color components. Drivers shall convert > + * ARGB16161616 value into appropriate format within planes atomic check. > + * > + * Drivers return an error from their plane atomic check if mask can't be > + * handled. > + * > + * colorkey.min, colorkey.max: > + * These two properties specify the colors that are treated as the color > + * key. Pixel whose value is in the [min, max] range is the color key > + * matching pixel. The minimum and maximum values are expressed as a > + * 64-bit integer in ARGB16161616 format, where A is the alpha value and > + * R, G and B correspond to the color components. Drivers shall convert > + * ARGB16161616 value into appropriate format within planes atomic check. > + * The converted value shall be *rounded up* to the nearest value. > + * > + * When a single color key is desired instead of a range, userspace shall > + * set the min and max properties to the same value. > + * > + * Drivers return an error from their plane atomic check if range can't be > + * handled. > + * > + * Returns: > + * Zero on success, negative errno on failure. > + */ While you're defining the concept of source and destination planes, it's not clear from the documentation how all this maps to the usual source and destination color keying concepts. I think that should be documented as well or users will be confused. Examples could help in this area. [snip] > diff --git a/include/drm/drm_plane.h b/include/drm/drm_plane.h > index 8a152dc16ea5..ab6a91e6b54e 100644 > --- a/include/drm/drm_plane.h > +++ b/include/drm/drm_plane.h [snip] > @@ -32,6 +33,52 @@ struct drm_crtc; > struct drm_printer; > struct drm_modeset_acquire_ctx; > > +/** > + * enum drm_plane_colorkey_mode - uapi plane colorkey mode enumeration > + */ If it's uAPI, should it be moved to include/uapi/drm/ ? > +enum drm_plane_colorkey_mode { > + /** > + * @DRM_PLANE_COLORKEY_MODE_DISABLED: > + * > + * No color matching performed in this mode. Do you mean "No color keying" ? > + */ > + DRM_PLANE_COLORKEY_MODE_DISABLED, > + > + /** > + * @DRM_PLANE_COLORKEY_MODE_TRANSPARENT: > + * > + * Destination plane pixels are completely transparent in areas > + * where pixels of a source plane are matching a given color key > + * range, in other cases pixels of a destination plane are unaffected. How do we handle hardware that performs configurable color replacement instead of a fixed fully transparency ? That was included in my original proposal and available in R-Car hardware. > + * In areas where two or more source planes overlap, the topmost > + * plane takes precedence. > + */ > + DRM_PLANE_COLORKEY_MODE_TRANSPARENT, > + > + /** > + * @DRM_PLANE_COLORKEY_MODES_NUM: > + * > + * Total number of color keying modes. > + */ > + DRM_PLANE_COLORKEY_MODES_NUM, This one, however, shouldn't be part of the uAPI as it will change when we will add new modes. > +}; [snip] > @@ -779,5 +846,29 @@ static inline struct drm_plane *drm_plane_find(struct > drm_device *dev, #define drm_for_each_plane(plane, dev) \ > list_for_each_entry(plane, &(dev)->mode_config.plane_list, head) > > +/** > + * drm_colorkey_extract_component - get color key component value > + * @ckey64: 64bit color key value > + * @comp_name: name of 16bit color component to extract > + * @nbits: size in bits of extracted component value > + * > + * Extract 16bit color component of @ckey64 given by @comp_name (alpha, > red, > + * green or blue) and convert it to an unsigned integer that has bit-width > + * of @nbits (result is rounded-up). > + */ > +#define drm_colorkey_extract_component(ckey64, comp_name, nbits) \ > + __DRM_CKEY_CLAMP(__DRM_CKEY_CONV(ckey64, comp_name, nbits), nbits) > + > +#define __drm_ckey_alpha_shift 48 > +#define __drm_ckey_red_shift 32 > +#define __drm_ckey_green_shift 16 > +#define __drm_ckey_blue_shift 0 > + > +#define __DRM_CKEY_CONV(ckey64, comp_name, nbits) \ > + DIV_ROUND_UP((u16)((ckey64) >> __drm_ckey_ ## comp_name ## _shift), \ > + 1 << (16 - (nbits))) As the divisor is a power of two, could we use masking instead of a division ? Or do you expect the compiler to optimize it properly ? > +#define __DRM_CKEY_CLAMP(value, nbits) \ > + min_t(u16, (value), (1 << (nbits)) - 1) Would the following be simpler to read and a bit more efficient as it avoids the division ? static inline u16 __drm_colorkey_extract_component(u64 ckey64, unsigned int shift, unsigned int nbits) { u16 mask = (1 << (16 - nbits)) - 1; return ((u16)(ckey >> shift) + mask) >> (16 - nbits); } #define drm_colorkey_extract_component(ckey64, comp_name, nbits) \ __drm_colorkey_extract_component(ckey64, __drm_ckey_ ## comp_name ## _shift, nbits) > #endif -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [RFC PATCH v4 1/2] drm: Add generic colorkey properties for display planes Date: Tue, 14 Aug 2018 12:48:08 +0300 Message-ID: <7041537.TPdt8DIvGD@avalon> References: <20180807172202.1961-1-digetx@gmail.com> <20180807172202.1961-2-digetx@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180807172202.1961-2-digetx@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Dmitry Osipenko Cc: linux-renesas-soc@vger.kernel.org, Thomas Hellstrom , Laurent Pinchart , Neil Armstrong , Russell King , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, Paul Kocialkowski , linux-tegra@vger.kernel.org, Thierry Reding , Ben Skeggs , Rodrigo Vivi , Maxime Ripard , linux-media@vger.kernel.org List-Id: linux-tegra@vger.kernel.org SGkgRG1pdHJ5LAoKVGhhbmsgeW91IGZvciB0aGUgcGF0Y2guCgpPbiBUdWVzZGF5LCA3IEF1Z3Vz dCAyMDE4IDIwOjIyOjAxIEVFU1QgRG1pdHJ5IE9zaXBlbmtvIHdyb3RlOgo+IEZyb206IExhdXJl bnQgUGluY2hhcnQgPGxhdXJlbnQucGluY2hhcnQrcmVuZXNhc0BpZGVhc29uYm9hcmQuY29tPgo+ IAo+IENvbG9yIGtleWluZyBpcyB0aGUgYWN0aW9uIG9mIHJlcGxhY2luZyBwaXhlbHMgbWF0Y2hp bmcgYSBnaXZlbiBjb2xvcgo+IChvciByYW5nZSBvZiBjb2xvcnMpIHdpdGggdHJhbnNwYXJlbnQg cGl4ZWxzIGluIGFuIG92ZXJsYXkgd2hlbgo+IHBlcmZvcm1pbmcgYmxpdHRpbmcuIERlcGVuZGlu ZyBvbiB0aGUgaGFyZHdhcmUgY2FwYWJpbGl0aWVzLCB0aGUKPiBtYXRjaGluZyBwaXhlbCBjYW4g ZWl0aGVyIGJlY29tZSBmdWxseSB0cmFuc3BhcmVudCBvciBnYWluIGFkanVzdG1lbnQKPiBvZiB0 aGUgcGl4ZWxzIGNvbXBvbmVudCB2YWx1ZXMuCj4gCj4gQ29sb3Iga2V5aW5nIGlzIGZvdW5kIGlu IGEgbGFyZ2UgbnVtYmVyIG9mIGRldmljZXMgd2hvc2UgY2FwYWJpbGl0aWVzCj4gb2Z0ZW4gZGlm ZmVyLCBidXQgdGhleSBzdGlsbCBoYXZlIGVub3VnaCBjb21tb24gZmVhdHVyZXMgaW4gcmFuZ2Ug dG8KPiBzdGFuZGFyZGl6ZSBjb2xvciBrZXkgcHJvcGVydGllcy4gVGhpcyBjb21taXQgYWRkcyBu ZXcgZ2VuZXJpYyBEUk0gcGxhbmUKPiBwcm9wZXJ0aWVzIHJlbGF0ZWQgdG8gdGhlIGNvbG9yIGtl eWluZywgcHJvdmlkaW5nIGluaXRpYWwgY29sb3Iga2V5aW5nCj4gc3VwcG9ydC4KPiAKPiBTaWdu ZWQtb2ZmLWJ5OiBMYXVyZW50IFBpbmNoYXJ0IDxsYXVyZW50LnBpbmNoYXJ0K3JlbmVzYXNAaWRl YXNvbmJvYXJkLmNvbT4KPiBTaWduZWQtb2ZmLWJ5OiBEbWl0cnkgT3NpcGVua28gPGRpZ2V0eEBn bWFpbC5jb20+Cj4gLS0tCj4gIGRyaXZlcnMvZ3B1L2RybS9kcm1fYXRvbWljLmMgfCAgMjAgKysr KysKPiAgZHJpdmVycy9ncHUvZHJtL2RybV9ibGVuZC5jICB8IDE1MCArKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKwo+ICBpbmNsdWRlL2RybS9kcm1fYmxlbmQuaCAgICAgIHwgICAz ICsKPiAgaW5jbHVkZS9kcm0vZHJtX3BsYW5lLmggICAgICB8ICA5MSArKysrKysrKysrKysrKysr KysrKysKPiAgNCBmaWxlcyBjaGFuZ2VkLCAyNjQgaW5zZXJ0aW9ucygrKQoKW3NuaXBdCgo+IGRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2JsZW5kLmMgYi9kcml2ZXJzL2dwdS9kcm0v ZHJtX2JsZW5kLmMKPiBpbmRleCBhMTZhNzRkN2UxNWUuLjEzYzYxZGQwZDliNyAxMDA2NDQKPiAt LS0gYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2JsZW5kLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0v ZHJtX2JsZW5kLmMKPiBAQCAtMTA3LDYgKzEwNywxMSBAQAo+ICAgKglwbGFuZXMuIFdpdGhvdXQg dGhpcyBwcm9wZXJ0eSB0aGUgcHJpbWFyeSBwbGFuZSBpcyBhbHdheXMgYmVsb3cgdGhlCj4gY3Vy c29yICoJcGxhbmUsIGFuZCBvcmRlcmluZyBiZXR3ZWVuIGFsbCBvdGhlciBwbGFuZXMgaXMgdW5k ZWZpbmVkLgo+ICAgKgo+ICsgKiBjb2xvcmtleToKPiArICoJQ29sb3Iga2V5aW5nIGlzIHNldCB1 cCB3aXRoIGRybV9wbGFuZV9jcmVhdGVfY29sb3JrZXlfcHJvcGVydGllcygpLgo+ICsgKglJdCBh ZGRzIHN1cHBvcnQgZm9yIGFjdGlvbnMgbGlrZSByZXBsYWNpbmcgYSByYW5nZSBvZiBjb2xvcnMg d2l0aCBhCj4gKyAqCXRyYW5zcGFyZW50IGNvbG9yIGluIHRoZSBwbGFuZS4gQ29sb3Iga2V5aW5n IGlzIGRpc2FibGVkIGJ5IGRlZmF1bHQuCj4gKyAqCj4gICAqIE5vdGUgdGhhdCBhbGwgdGhlIHBy b3BlcnR5IGV4dGVuc2lvbnMgZGVzY3JpYmVkIGhlcmUgYXBwbHkgZWl0aGVyIHRvIHRoZQo+ICog cGxhbmUgb3IgdGhlIENSVEMgKGUuZy4gZm9yIHRoZSBiYWNrZ3JvdW5kIGNvbG9yLCB3aGljaCBj dXJyZW50bHkgaXMgbm90Cj4gKiBleHBvc2VkIGFuZCBhc3N1bWVkIHRvIGJlIGJsYWNrKS4KPiBA QCAtNDQ4LDMgKzQ1MywxNDggQEAgaW50IGRybV9hdG9taWNfbm9ybWFsaXplX3pwb3Moc3RydWN0 IGRybV9kZXZpY2UgKmRldiwKPiAgCXJldHVybiAwOwo+ICB9Cj4gIEVYUE9SVF9TWU1CT0woZHJt X2F0b21pY19ub3JtYWxpemVfenBvcyk7Cj4gKwo+ICtzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0 IHBsYW5lX2NvbG9ya2V5X21vZGVfbmFtZVtdID0gewo+ICsJW0RSTV9QTEFORV9DT0xPUktFWV9N T0RFX0RJU0FCTEVEXSA9ICJkaXNhYmxlZCIsCj4gKwlbRFJNX1BMQU5FX0NPTE9SS0VZX01PREVf VFJBTlNQQVJFTlRdID0gInRyYW5zcGFyZW50IiwKPiArfTsKPiArCj4gKy8qKgo+ICsgKiBkcm1f cGxhbmVfY3JlYXRlX2NvbG9ya2V5X3Byb3BlcnRpZXMgLSBjcmVhdGUgY29sb3JrZXkgcHJvcGVy dGllcwo+ICsgKiBAcGxhbmU6IGRybSBwbGFuZQo+ICsgKiBAc3VwcG9ydGVkX21vZGVzOiBiaXRt YXNrIG9mIHN1cHBvcnRlZCBjb2xvciBrZXlpbmcgbW9kZXMKPiArICoKPiArICogVGhpcyBmdW5j dGlvbiBjcmVhdGVzIHRoZSBnZW5lcmljIGNvbG9yIGtleWluZyBwcm9wZXJ0aWVzIGFuZCBhdHRh Y2hlcwo+IHRoZW0KPiArICogdG8gdGhlIEBwbGFuZSB0byBlbmFibGUgY29sb3Iga2V5aW5nIGNv bnRyb2wgZm9yIGJsZW5kaW5nIG9wZXJhdGlvbnMuCj4gKyAqCj4gKyAqIEdsb3NzYXJ5Ogo+ICsg Kgo+ICsgKiBEZXN0aW5hdGlvbiBwbGFuZToKPiArICoJUGxhbmUgdG8gd2hpY2ggY29sb3Iga2V5 aW5nIHByb3BlcnRpZXMgYXJlIGFwcGxpZWQsIHRoaXMgcGxhbmVzIHRha2VzCj4gKyAqCXRoZSBl ZmZlY3Qgb2YgY29sb3Iga2V5aW5nIG9wZXJhdGlvbi4gVGhlIGVmZmVjdCBpcyBkZXRlcm1pbmVk IGJ5IGEKPiArICoJZ2l2ZW4gY29sb3Iga2V5aW5nIG1vZGUuCj4gKyAqCj4gKyAqIFNvdXJjZSBw bGFuZToKPiArICoJUGl4ZWxzIG9mIHRoaXMgcGxhbmUgYXJlIHRoZSBzb3VyY2UgZm9yIGNvbG9y IGtleSBtYXRjaGluZyBvcGVyYXRpb24uCj4gKyAqCj4gKyAqIENvbG9yIGtleWluZyBpcyBjb250 cm9sbGVkIGJ5IHRoZXNlIHByb3BlcnRpZXM6Cj4gKyAqCj4gKyAqIGNvbG9ya2V5LnBsYW5lX21h c2s6Cj4gKyAqCVRoZSBtYXNrIHByb3BlcnR5IHNwZWNpZmllcyB3aGljaCBwbGFuZXMgcGFydGlj aXBhdGUgaW4gY29sb3Iga2V5Cj4gKyAqCW1hdGNoaW5nIHByb2Nlc3MsIHRoZXNlIHBsYW5lcyBh cmUgdGhlIGNvbG9yIGtleSBzb3VyY2VzLgo+ICsgKgo+ICsgKglEcml2ZXJzIHJldHVybiBhbiBl cnJvciBmcm9tIHRoZWlyIHBsYW5lIGF0b21pYyBjaGVjayBpZiBwbGFuZSBjYW4ndCBiZQo+ICsg KgloYW5kbGVkLgoKVGhpcyBzZWVtcyBmcmFnaWxlIHRvIG1lLiBXZSBkb24ndCBkb2N1bWVudCBo b3cgdXNlcnNwYWNlIGRldGVybWluZXMgd2hpY2ggCnBsYW5lcyBuZWVkIHRvIGJlIHNwZWNpZmll ZCBoZXJlLCBhbmQgd2UgZG9uJ3QgZG9jdW1lbnQgd2hhdCBoYXBwZW5zIGlmIGEgCnBsYW5lIHVu ZGVybmVhdGggdGhlIGRlc3RpbmF0aW9uIHBsYW5lIGlzIG5vdCBzcGVjaWZpZWQgaW4gdGhlIG1h c2suIE1vcmUgCnByZWNpc2UgZG9jdW1lbnRhdGlvbiBpcyBuZWVkZWQgaWYgd2Ugd2FudCB0byB1 c2Ugc3VjaCBhIHByb3BlcnR5LgoKSXQgYWxzbyBzZWVtcyBxdWl0ZSBjb21wbGV4LiBJcyBhbiBl eHBsaWNpdCBwbGFuZSBtYXNrIHJlYWxseSB0aGUgYmVzdCBvcHRpb24gCj8gV2hhdCdzIHRoZSBy ZWFzb24gd2h5IHBsYW5lcyBjb3VsZG4ndCBiZSBoYW5kbGVkID8gSG93IGRvIGRyaXZlcnMgZGV0 ZXJtaW5lIAp0aGF0ID8KCj4gKyAqIGNvbG9ya2V5Lm1vZGU6Cj4gKyAqCVRoZSBtb2RlIGlzIGFu IGVudW1lcmF0ZWQgcHJvcGVydHkgdGhhdCBjb250cm9scyBob3cgY29sb3Iga2V5aW5nCj4gKyAq CW9wZXJhdGVzLgoKQSBsaW5rIHRvIHRoZSBkcm1fcGxhbmVfY29sb3JrZXlfbW9kZSBlbnVtIGRv Y3VtZW50YXRpb24gd291bGQgYmUgdXNlZnVsLgoKPiArICogY29sb3JrZXkubWFzazoKPiArICoJ VGhpcyBwcm9wZXJ0eSBzcGVjaWZpZXMgdGhlIHBpeGVsIGNvbXBvbmVudHMgbWFzay4gVW5tYXNr ZWQgcGl4ZWwKPiArICoJY29tcG9uZW50cyBhcmUgbm90IHBhcnRpY2lwYXRpbmcgaW4gdGhlIG1h dGNoaW5nLiBUaGlzIG1hc2sgdmFsdWUgaXMKPiArICoJYXBwbGllZCB0byBjb2xvcmtleS5taW4g LyBtYXggdmFsdWVzLiBUaGUgbWFzayB2YWx1ZSBpcyBnaXZlbiBpbiBhCj4gKyAqCTY0LWJpdCBp bnRlZ2VyIGluIEFSR0IxNjE2MTYxNiBmb3JtYXQsIHdoZXJlIEEgaXMgdGhlIGFscGhhIHZhbHVl IGFuZAo+ICsgKglSLCBHIGFuZCBCIGNvcnJlc3BvbmQgdG8gdGhlIGNvbG9yIGNvbXBvbmVudHMu IERyaXZlcnMgc2hhbGwgY29udmVydAo+ICsgKglBUkdCMTYxNjE2MTYgdmFsdWUgaW50byBhcHBy b3ByaWF0ZSBmb3JtYXQgd2l0aGluIHBsYW5lcyBhdG9taWMgY2hlY2suCj4gKyAqCj4gKyAqCURy aXZlcnMgcmV0dXJuIGFuIGVycm9yIGZyb20gdGhlaXIgcGxhbmUgYXRvbWljIGNoZWNrIGlmIG1h c2sgY2FuJ3QgYmUKPiArICoJaGFuZGxlZC4KPiArICoKPiArICogY29sb3JrZXkubWluLCBjb2xv cmtleS5tYXg6Cj4gKyAqCVRoZXNlIHR3byBwcm9wZXJ0aWVzIHNwZWNpZnkgdGhlIGNvbG9ycyB0 aGF0IGFyZSB0cmVhdGVkIGFzIHRoZSBjb2xvcgo+ICsgKglrZXkuIFBpeGVsIHdob3NlIHZhbHVl IGlzIGluIHRoZSBbbWluLCBtYXhdIHJhbmdlIGlzIHRoZSBjb2xvciBrZXkKPiArICoJbWF0Y2hp bmcgcGl4ZWwuIFRoZSBtaW5pbXVtIGFuZCBtYXhpbXVtIHZhbHVlcyBhcmUgZXhwcmVzc2VkIGFz IGEKPiArICoJNjQtYml0IGludGVnZXIgaW4gQVJHQjE2MTYxNjE2IGZvcm1hdCwgd2hlcmUgQSBp cyB0aGUgYWxwaGEgdmFsdWUgYW5kCj4gKyAqCVIsIEcgYW5kIEIgY29ycmVzcG9uZCB0byB0aGUg Y29sb3IgY29tcG9uZW50cy4gRHJpdmVycyBzaGFsbCBjb252ZXJ0Cj4gKyAqCUFSR0IxNjE2MTYx NiB2YWx1ZSBpbnRvIGFwcHJvcHJpYXRlIGZvcm1hdCB3aXRoaW4gcGxhbmVzIGF0b21pYyBjaGVj ay4KPiArICoJVGhlIGNvbnZlcnRlZCB2YWx1ZSBzaGFsbCBiZSAqcm91bmRlZCB1cCogdG8gdGhl IG5lYXJlc3QgdmFsdWUuCj4gKyAqCj4gKyAqCVdoZW4gYSBzaW5nbGUgY29sb3Iga2V5IGlzIGRl c2lyZWQgaW5zdGVhZCBvZiBhIHJhbmdlLCB1c2Vyc3BhY2Ugc2hhbGwKPiArICoJc2V0IHRoZSBt aW4gYW5kIG1heCBwcm9wZXJ0aWVzIHRvIHRoZSBzYW1lIHZhbHVlLgo+ICsgKgo+ICsgKglEcml2 ZXJzIHJldHVybiBhbiBlcnJvciBmcm9tIHRoZWlyIHBsYW5lIGF0b21pYyBjaGVjayBpZiByYW5n ZSBjYW4ndCBiZQo+ICsgKgloYW5kbGVkLgo+ICsgKgo+ICsgKiBSZXR1cm5zOgo+ICsgKiBaZXJv IG9uIHN1Y2Nlc3MsIG5lZ2F0aXZlIGVycm5vIG9uIGZhaWx1cmUuCj4gKyAqLwoKV2hpbGUgeW91 J3JlIGRlZmluaW5nIHRoZSBjb25jZXB0IG9mIHNvdXJjZSBhbmQgZGVzdGluYXRpb24gcGxhbmVz LCBpdCdzIG5vdCAKY2xlYXIgZnJvbSB0aGUgZG9jdW1lbnRhdGlvbiBob3cgYWxsIHRoaXMgbWFw cyB0byB0aGUgdXN1YWwgc291cmNlIGFuZCAKZGVzdGluYXRpb24gY29sb3Iga2V5aW5nIGNvbmNl cHRzLiBJIHRoaW5rIHRoYXQgc2hvdWxkIGJlIGRvY3VtZW50ZWQgYXMgd2VsbCAKb3IgdXNlcnMg d2lsbCBiZSBjb25mdXNlZC4gRXhhbXBsZXMgY291bGQgaGVscCBpbiB0aGlzIGFyZWEuCgpbc25p cF0KCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJtL2RybV9wbGFuZS5oIGIvaW5jbHVkZS9kcm0v ZHJtX3BsYW5lLmgKPiBpbmRleCA4YTE1MmRjMTZlYTUuLmFiNmE5MWU2YjU0ZSAxMDA2NDQKPiAt LS0gYS9pbmNsdWRlL2RybS9kcm1fcGxhbmUuaAo+ICsrKyBiL2luY2x1ZGUvZHJtL2RybV9wbGFu ZS5oCgpbc25pcF0KCj4gQEAgLTMyLDYgKzMzLDUyIEBAIHN0cnVjdCBkcm1fY3J0YzsKPiAgc3Ry dWN0IGRybV9wcmludGVyOwo+ICBzdHJ1Y3QgZHJtX21vZGVzZXRfYWNxdWlyZV9jdHg7Cj4gCj4g Ky8qKgo+ICsgKiBlbnVtIGRybV9wbGFuZV9jb2xvcmtleV9tb2RlIC0gdWFwaSBwbGFuZSBjb2xv cmtleSBtb2RlIGVudW1lcmF0aW9uCj4gKyAqLwoKSWYgaXQncyB1QVBJLCBzaG91bGQgaXQgYmUg bW92ZWQgdG8gaW5jbHVkZS91YXBpL2RybS8gPwoKPiArZW51bSBkcm1fcGxhbmVfY29sb3JrZXlf bW9kZSB7Cj4gKwkvKioKPiArCSAqIEBEUk1fUExBTkVfQ09MT1JLRVlfTU9ERV9ESVNBQkxFRDoK PiArCSAqCj4gKwkgKiBObyBjb2xvciBtYXRjaGluZyBwZXJmb3JtZWQgaW4gdGhpcyBtb2RlLgoK RG8geW91IG1lYW4gIk5vIGNvbG9yIGtleWluZyIgPwoKPiArCSAqLwo+ICsJRFJNX1BMQU5FX0NP TE9SS0VZX01PREVfRElTQUJMRUQsCj4gKwo+ICsJLyoqCj4gKwkgKiBARFJNX1BMQU5FX0NPTE9S S0VZX01PREVfVFJBTlNQQVJFTlQ6Cj4gKwkgKgo+ICsJICogRGVzdGluYXRpb24gcGxhbmUgcGl4 ZWxzIGFyZSBjb21wbGV0ZWx5IHRyYW5zcGFyZW50IGluIGFyZWFzCj4gKwkgKiB3aGVyZSBwaXhl bHMgb2YgYSBzb3VyY2UgcGxhbmUgYXJlIG1hdGNoaW5nIGEgZ2l2ZW4gY29sb3Iga2V5Cj4gKwkg KiByYW5nZSwgaW4gb3RoZXIgY2FzZXMgcGl4ZWxzIG9mIGEgZGVzdGluYXRpb24gcGxhbmUgYXJl IHVuYWZmZWN0ZWQuCgpIb3cgZG8gd2UgaGFuZGxlIGhhcmR3YXJlIHRoYXQgcGVyZm9ybXMgY29u ZmlndXJhYmxlIGNvbG9yIHJlcGxhY2VtZW50IGluc3RlYWQgCm9mIGEgZml4ZWQgZnVsbHkgdHJh bnNwYXJlbmN5ID8gVGhhdCB3YXMgaW5jbHVkZWQgaW4gbXkgb3JpZ2luYWwgcHJvcG9zYWwgYW5k IAphdmFpbGFibGUgaW4gUi1DYXIgaGFyZHdhcmUuCgo+ICsJICogSW4gYXJlYXMgd2hlcmUgdHdv IG9yIG1vcmUgc291cmNlIHBsYW5lcyBvdmVybGFwLCB0aGUgdG9wbW9zdAo+ICsJICogcGxhbmUg dGFrZXMgcHJlY2VkZW5jZS4KPiArCSAqLwo+ICsJRFJNX1BMQU5FX0NPTE9SS0VZX01PREVfVFJB TlNQQVJFTlQsCj4gKwo+ICsJLyoqCj4gKwkgKiBARFJNX1BMQU5FX0NPTE9SS0VZX01PREVTX05V TToKPiArCSAqCj4gKwkgKiBUb3RhbCBudW1iZXIgb2YgY29sb3Iga2V5aW5nIG1vZGVzLgo+ICsJ ICovCj4gKwlEUk1fUExBTkVfQ09MT1JLRVlfTU9ERVNfTlVNLAoKVGhpcyBvbmUsIGhvd2V2ZXIs IHNob3VsZG4ndCBiZSBwYXJ0IG9mIHRoZSB1QVBJIGFzIGl0IHdpbGwgY2hhbmdlIHdoZW4gd2Ug CndpbGwgYWRkIG5ldyBtb2Rlcy4KCj4gK307Cgpbc25pcF0KCj4gQEAgLTc3OSw1ICs4NDYsMjkg QEAgc3RhdGljIGlubGluZSBzdHJ1Y3QgZHJtX3BsYW5lICpkcm1fcGxhbmVfZmluZChzdHJ1Y3QK PiBkcm1fZGV2aWNlICpkZXYsICNkZWZpbmUgZHJtX2Zvcl9lYWNoX3BsYW5lKHBsYW5lLCBkZXYp IFwKPiAgCWxpc3RfZm9yX2VhY2hfZW50cnkocGxhbmUsICYoZGV2KS0+bW9kZV9jb25maWcucGxh bmVfbGlzdCwgaGVhZCkKPiAKPiArLyoqCj4gKyAqIGRybV9jb2xvcmtleV9leHRyYWN0X2NvbXBv bmVudCAtIGdldCBjb2xvciBrZXkgY29tcG9uZW50IHZhbHVlCj4gKyAqIEBja2V5NjQ6IDY0Yml0 IGNvbG9yIGtleSB2YWx1ZQo+ICsgKiBAY29tcF9uYW1lOiBuYW1lIG9mIDE2Yml0IGNvbG9yIGNv bXBvbmVudCB0byBleHRyYWN0Cj4gKyAqIEBuYml0czogc2l6ZSBpbiBiaXRzIG9mIGV4dHJhY3Rl ZCBjb21wb25lbnQgdmFsdWUKPiArICoKPiArICogRXh0cmFjdCAxNmJpdCBjb2xvciBjb21wb25l bnQgb2YgQGNrZXk2NCBnaXZlbiBieSBAY29tcF9uYW1lIChhbHBoYSwKPiByZWQsCj4gKyAqIGdy ZWVuIG9yIGJsdWUpIGFuZCBjb252ZXJ0IGl0IHRvIGFuIHVuc2lnbmVkIGludGVnZXIgdGhhdCBo YXMgYml0LXdpZHRoCj4gKyAqIG9mIEBuYml0cyAocmVzdWx0IGlzIHJvdW5kZWQtdXApLgo+ICsg Ki8KPiArI2RlZmluZSBkcm1fY29sb3JrZXlfZXh0cmFjdF9jb21wb25lbnQoY2tleTY0LCBjb21w X25hbWUsIG5iaXRzKSBcCj4gKwlfX0RSTV9DS0VZX0NMQU1QKF9fRFJNX0NLRVlfQ09OVihja2V5 NjQsIGNvbXBfbmFtZSwgbmJpdHMpLCBuYml0cykKPiArCj4gKyNkZWZpbmUgX19kcm1fY2tleV9h bHBoYV9zaGlmdAk0OAo+ICsjZGVmaW5lIF9fZHJtX2NrZXlfcmVkX3NoaWZ0CTMyCj4gKyNkZWZp bmUgX19kcm1fY2tleV9ncmVlbl9zaGlmdAkxNgo+ICsjZGVmaW5lIF9fZHJtX2NrZXlfYmx1ZV9z aGlmdAkwCj4gKwo+ICsjZGVmaW5lIF9fRFJNX0NLRVlfQ09OVihja2V5NjQsIGNvbXBfbmFtZSwg bmJpdHMpIFwKPiArCURJVl9ST1VORF9VUCgodTE2KSgoY2tleTY0KSA+PiBfX2RybV9ja2V5XyAj IyBjb21wX25hbWUgIyMgX3NoaWZ0KSwgXAo+ICsJCSAgICAgMSA8PCAoMTYgLSAobmJpdHMpKSkK CkFzIHRoZSBkaXZpc29yIGlzIGEgcG93ZXIgb2YgdHdvLCBjb3VsZCB3ZSB1c2UgbWFza2luZyBp bnN0ZWFkIG9mIGEgZGl2aXNpb24gPyAKT3IgZG8geW91IGV4cGVjdCB0aGUgY29tcGlsZXIgdG8g b3B0aW1pemUgaXQgcHJvcGVybHkgPwoKPiArI2RlZmluZSBfX0RSTV9DS0VZX0NMQU1QKHZhbHVl LCBuYml0cykgXAo+ICsJbWluX3QodTE2LCAodmFsdWUpLCAoMSA8PCAobmJpdHMpKSAtIDEpCgpX b3VsZCB0aGUgZm9sbG93aW5nIGJlIHNpbXBsZXIgdG8gcmVhZCBhbmQgYSBiaXQgbW9yZSBlZmZp Y2llbnQgYXMgaXQgYXZvaWRzIAp0aGUgZGl2aXNpb24gPwoKc3RhdGljIGlubGluZSB1MTYgX19k cm1fY29sb3JrZXlfZXh0cmFjdF9jb21wb25lbnQodTY0IGNrZXk2NCwgCiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVuc2lnbmVkIGludCBzaGlmdCwg CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVuc2ln bmVkIGludCBuYml0cykKeyAgICAgICAKICAgICAgICB1MTYgbWFzayA9ICgxIDw8ICgxNiAtIG5i aXRzKSkgLSAxOwogICAgICAgIAogICAgICAgIHJldHVybiAoKHUxNikoY2tleSA+PiBzaGlmdCkg KyBtYXNrKSA+PiAoMTYgLSBuYml0cyk7Cn0KCiNkZWZpbmUgZHJtX2NvbG9ya2V5X2V4dHJhY3Rf Y29tcG9uZW50KGNrZXk2NCwgY29tcF9uYW1lLCBuYml0cykgXAogICAgICAgIF9fZHJtX2NvbG9y a2V5X2V4dHJhY3RfY29tcG9uZW50KGNrZXk2NCwgX19kcm1fY2tleV8gIyMgY29tcF9uYW1lICMj IApfc2hpZnQsIG5iaXRzKQoKPiAgI2VuZGlmCgotLSAKUmVnYXJkcywKCkxhdXJlbnQgUGluY2hh cnQKCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJp LWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBz Oi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==