From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from galahad.ideasonboard.com ([185.26.127.97]:43565 "EHLO galahad.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751292AbdK0LMy (ORCPT ); Mon, 27 Nov 2017 06:12:54 -0500 From: Laurent Pinchart To: "Gheorghe, Alexandru" Cc: Daniel Vetter , Eric Anholt , "linux-renesas-soc@vger.kernel.org" , "dri-devel@lists.freedesktop.org" , "linux-media@vger.kernel.org" , "geert@linux-m68k.org" , "sergei.shtylyov@cogentembedded.com" Subject: Re: [PATCH v2 0/2] rcar-du, vsp1: rcar-gen3: Add support for colorkey alpha blending Date: Mon, 27 Nov 2017 13:12:57 +0200 Message-ID: <3672804.sDuinxb1Jr@avalon> In-Reply-To: References: <1494152007-30094-1-git-send-email-Alexandru_Gheorghe@mentor.com> <20170508182958.gmi6rrwog4anqxea@phenom.ffwll.local> 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 Alex et all, On Tuesday, 9 May 2017 10:12:31 EET Gheorghe, Alexandru wrote: > On Mon, Monday, May 8, 2017 9:29 PM +0200, Daniel Vetter wrote: > > On Mon, May 08, 2017 at 09:33:37AM -0700, Eric Anholt wrote: > >> Alexandru Gheorghe writes: > >>> Currently, rcar-du supports colorkeying only for rcar-gen2 and it > >>> uses some hw capability of the display unit(DU) which is not available > >>> on gen3. > >>> > >>> In order to implement colorkeying for gen3 we need to use the > >>> colorkey capability of the VSPD, hence the need to change both > >>> drivers rcar-du and vsp1. > >>> > >>> This patchset had been developed and tested on top of > >>> v4.9/rcar-3.5.1 from > >>> git://git.kernel.org/pub/scm/linux/kernel/git/horms/renesas-bsp.git > >> > >> A few questions: > >> > >> Are other drivers interested in supporting this property? VC4 has the > >> 24-bit RGB colorkey, but I don't see YCBCR support. Should it be > >> documented in a generic location? > > As far as I identified armada, i815, nouveau, rcar-du, vmwgfx drivers have > this notion of colorkey. There could be other HW which don't have this > implemented yet. Among those drivers only armada, nouveau and rcar-du expose the color key through DRM properties. The i915 and vmwgfx drivers use custom ioctls. Here is what is currently implemented. - armada "colorkey" range 0x00000000 0x00ffffff "colorkey_min" range 0x00000000 0x00ffffff "colorkey_max" range 0x00000000 0x00ffffff "colorkey_val" range 0x00000000 0x00ffffff "colorkey_alpha" range 0x00000000 0x00ffffff "colorkey_mode" enum "disable", "Y component", "U component", "V component", "RGB", "R component", "G component", "B component" All range properties store a RGB888 or YUV888 triplet. The min and max properties store the comparison ranges. When a match occurs for one of the components, the value and alpha from the val and alpha properties replace the pixel. It's not clear which of the alpha "components" is used when a match occurs in RGB mode. The colorkey property is a shortcut that stores identical values in min, max and val and 0 in alpha. - i915 #define I915_SET_COLORKEY_NONE (1<<0) #define I915_SET_COLORKEY_DESTINATION (1<<1) #define I915_SET_COLORKEY_SOURCE (1<<2) struct drm_intel_sprite_colorkey { __u32 plane_id; __u32 min_value; __u32 channel_mask; __u32 max_value; __u32 flags; }; - nouveau "colorkey" range 0x00000000 0x01ffffff The format isn't documented but it seems from the source code that bits 23:0 store the color key value (written directly to a register, so possibly in a pixel format-dependent format) and bit 24 enables color keying. - rcar-du "colorkey" range 0x00000000 0x01ffffff Bits 23:0 store the color key value in RGB888 (regardless of the pixel format of the plane) and bit 24 enables color keying. This supports Gen2 hardware only, where the only available more is exact match. The pixel then becomes fully transparent (the hardware doesn't support custom target alpha values). On Gen3 hardware color keying can be performed in exact RGB match, exact Y match or range Y match (only the max value is programmable, the min value is always 0). Furthermore in exact match modes the hardware can operate with a single match value, in which case it can then override the full ARGB or AYUV pixel, or double match value, in which case it can then override the alpha component only, but with two distinct match values each associated with a target alpha. - vmwgfx struct drm_vmw_control_stream_arg { __u32 stream_id; __u32 enabled; __u32 flags; __u32 color_key; __u32 handle; __u32 offset; __s32 format; __u32 size; __u32 width; __u32 height; __u32 pitch[3]; __u32 pad64; struct drm_vmw_rect src; struct drm_vmw_rect dst; }; The color_key field isn't documented, but the following (unused) macros hint that it could store an RGB888, with the color key feature enabled through the flags field. #define SVGA_VIDEO_FLAG_COLORKEY 0x0001 #define SVGA_VIDEO_COLORKEY_MASK 0x00ffffff > >> Does your colorkey end up forcing alpha to 1 for the plane when it's > >> not matched? > > I think this behavior is HW dependent, on R-CAR Gen3, the alpha for pixel > that don't match is not touch. > > > I think generic color-key for plane compositioning would be nice, but I'm > > not sure that's possible due to differences in how the key works. > > I'm thinking of starting from the drivers that do have this property and see > if there is any common ground for a generic color-key property/ies Looking at the 5 drivers we have in mainline that support color keying one way or another, we can already see that the hardware implementations differ quite widely. There are however similarities, and we could express most of the above features through a set of generic properties similar to the ones already implemented by the armada driver. - The match range could be set through minimum and maximum properties. Drivers that support exact match only would report an error with minimum != maximum. - The replacement value could be set through a value property. The property could store both the pixel value (RGB or YUV) and the alpha value, or we could separate those in two properties. With a single property bits that are not applicable would be ignored (for instance RGB/YUV bits when the driver supports alpha replacement only). If programmable color replacement isn't supported (as in the R-Car Gen2 example above) the property could be omitted. - The mode could be set through a mode property. Enabling color keying through one bit in a color property (like done by the nouveau and rcar-du drivers) is a hack and I don't think we should carry it forward. A mode property would also allow configuring source or destination color keying. - Part of the mode information could be deduced automatically without a need to specify it explicitly. For instance RGB/YUV mode can be configured based on the pixel format of the plane. Similarly, exact match vs. range match can be configured based on whether the minimum and maximum value differ. - Properties that store pixel values could either contain a value in a fixed format (e.g. RGB888) or in a format that varies depending on the pixel format (e.g. encoded in the same pixel format as the plane). I have a preference for the former but I'm open for discussions. - We need to keep the existing "colorkey" properties implemented by armada, nouveau and rcar-du for backward compatibility reasons, but this proposed API doesn't require a "colorkey" property. We could however decide to standardize a "colorkey" property as a shortcut similar to what the armada driver does. Some of the R-Car Gen3 hardware features wouldn't be supported by the above proposal. Selecting exact match vs. range match should be fine, with atomic commit returning an error if minimum != 0 && minimum != maximum. The dual target mode, however, can't really fit the properties proposed here. I don't have a use case for that mode at the moment but I'm fairly certain that someone will come up with one, at least if not for the R-Car for a different display engine that provides similarly exotic features. We could also decide to standardize the color keying properties in a way that would balance complexity vs. hardware features support, and let drivers that need exotic features implement additional properties. Ideas and comments are welcome, I'd like to start working on this fairly soon. -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH v2 0/2] rcar-du, vsp1: rcar-gen3: Add support for colorkey alpha blending Date: Mon, 27 Nov 2017 13:12:57 +0200 Message-ID: <3672804.sDuinxb1Jr@avalon> References: <1494152007-30094-1-git-send-email-Alexandru_Gheorghe@mentor.com> <20170508182958.gmi6rrwog4anqxea@phenom.ffwll.local> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from galahad.ideasonboard.com (galahad.ideasonboard.com [185.26.127.97]) by gabe.freedesktop.org (Postfix) with ESMTPS id 8CAF26E274 for ; Mon, 27 Nov 2017 11:12:54 +0000 (UTC) In-Reply-To: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: "Gheorghe, Alexandru" Cc: "sergei.shtylyov@cogentembedded.com" , "dri-devel@lists.freedesktop.org" , "linux-renesas-soc@vger.kernel.org" , "geert@linux-m68k.org" , "linux-media@vger.kernel.org" List-Id: dri-devel@lists.freedesktop.org SGkgQWxleCBldCBhbGwsCgpPbiBUdWVzZGF5LCA5IE1heSAyMDE3IDEwOjEyOjMxIEVFVCBHaGVv cmdoZSwgQWxleGFuZHJ1IHdyb3RlOgo+IE9uIE1vbiwgTW9uZGF5LCBNYXkgOCwgMjAxNyA5OjI5 IFBNICswMjAwLCBEYW5pZWwgVmV0dGVyIHdyb3RlOgo+ID4gT24gTW9uLCBNYXkgMDgsIDIwMTcg YXQgMDk6MzM6MzdBTSAtMDcwMCwgRXJpYyBBbmhvbHQgd3JvdGU6Cj4gPj4gQWxleGFuZHJ1IEdo ZW9yZ2hlIDxBbGV4YW5kcnVfR2hlb3JnaGVAbWVudG9yLmNvbT4gd3JpdGVzOgo+ID4+PiBDdXJy ZW50bHksIHJjYXItZHUgc3VwcG9ydHMgY29sb3JrZXlpbmcgIG9ubHkgZm9yIHJjYXItZ2VuMiBh bmQgaXQKPiA+Pj4gdXNlcyBzb21lIGh3IGNhcGFiaWxpdHkgb2YgdGhlIGRpc3BsYXkgdW5pdChE VSkgd2hpY2ggaXMgbm90IGF2YWlsYWJsZQo+ID4+PiBvbiBnZW4zLgo+ID4+PiAKPiA+Pj4gSW4g b3JkZXIgdG8gaW1wbGVtZW50IGNvbG9ya2V5aW5nIGZvciBnZW4zIHdlIG5lZWQgdG8gdXNlIHRo ZQo+ID4+PiBjb2xvcmtleSBjYXBhYmlsaXR5IG9mIHRoZSBWU1BELCBoZW5jZSB0aGUgbmVlZCB0 byBjaGFuZ2UgYm90aAo+ID4+PiBkcml2ZXJzIHJjYXItZHUgYW5kIHZzcDEuCj4gPj4+IAo+ID4+ PiBUaGlzIHBhdGNoc2V0IGhhZCBiZWVuIGRldmVsb3BlZCBhbmQgdGVzdGVkIG9uIHRvcCBvZgo+ ID4+PiB2NC45L3JjYXItMy41LjEgZnJvbQo+ID4+PiBnaXQ6Ly9naXQua2VybmVsLm9yZy9wdWIv c2NtL2xpbnV4L2tlcm5lbC9naXQvaG9ybXMvcmVuZXNhcy1ic3AuZ2l0Cj4gPj4gCj4gPj4gQSBm ZXcgcXVlc3Rpb25zOgo+ID4+IAo+ID4+IEFyZSBvdGhlciBkcml2ZXJzIGludGVyZXN0ZWQgaW4g c3VwcG9ydGluZyB0aGlzIHByb3BlcnR5PyAgVkM0IGhhcyB0aGUKPiA+PiAyNC1iaXQgUkdCIGNv bG9ya2V5LCBidXQgSSBkb24ndCBzZWUgWUNCQ1Igc3VwcG9ydC4gIFNob3VsZCBpdCBiZQo+ID4+ IGRvY3VtZW50ZWQgaW4gYSBnZW5lcmljIGxvY2F0aW9uPwo+IAo+IEFzIGZhciBhcyBJIGlkZW50 aWZpZWQgIGFybWFkYSwgaTgxNSwgbm91dmVhdSwgcmNhci1kdSwgdm13Z2Z4IGRyaXZlcnMgaGF2 ZQo+IHRoaXMgbm90aW9uIG9mIGNvbG9ya2V5LiBUaGVyZSBjb3VsZCBiZSBvdGhlciBIVyB3aGlj aCBkb24ndCBoYXZlIHRoaXMKPiBpbXBsZW1lbnRlZCB5ZXQuCgpBbW9uZyB0aG9zZSBkcml2ZXJz IG9ubHkgYXJtYWRhLCBub3V2ZWF1IGFuZCByY2FyLWR1IGV4cG9zZSB0aGUgY29sb3Iga2V5IAp0 aHJvdWdoIERSTSBwcm9wZXJ0aWVzLiBUaGUgaTkxNSBhbmQgdm13Z2Z4IGRyaXZlcnMgdXNlIGN1 c3RvbSBpb2N0bHMuIEhlcmUgaXMgCndoYXQgaXMgY3VycmVudGx5IGltcGxlbWVudGVkLgoKLSBh cm1hZGEKCiJjb2xvcmtleSIgcmFuZ2UgIDB4MDAwMDAwMDAgMHgwMGZmZmZmZgoiY29sb3JrZXlf bWluIiByYW5nZSAgMHgwMDAwMDAwMCAweDAwZmZmZmZmCiJjb2xvcmtleV9tYXgiIHJhbmdlICAw eDAwMDAwMDAwIDB4MDBmZmZmZmYKImNvbG9ya2V5X3ZhbCIgcmFuZ2UgIDB4MDAwMDAwMDAgMHgw MGZmZmZmZgoiY29sb3JrZXlfYWxwaGEiIHJhbmdlICAweDAwMDAwMDAwIDB4MDBmZmZmZmYKImNv bG9ya2V5X21vZGUiIGVudW0gImRpc2FibGUiLCAiWSBjb21wb25lbnQiLCAiVSBjb21wb25lbnQi LCAiViBjb21wb25lbnQiLCAKIlJHQiIsICJSIGNvbXBvbmVudCIsICJHIGNvbXBvbmVudCIsICJC IGNvbXBvbmVudCIKCkFsbCByYW5nZSBwcm9wZXJ0aWVzIHN0b3JlIGEgUkdCODg4IG9yIFlVVjg4 OCB0cmlwbGV0LgoKVGhlIG1pbiBhbmQgbWF4IHByb3BlcnRpZXMgc3RvcmUgdGhlIGNvbXBhcmlz b24gcmFuZ2VzLiBXaGVuIGEgbWF0Y2ggb2NjdXJzIApmb3Igb25lIG9mIHRoZSBjb21wb25lbnRz LCB0aGUgdmFsdWUgYW5kIGFscGhhIGZyb20gdGhlIHZhbCBhbmQgYWxwaGEgCnByb3BlcnRpZXMg cmVwbGFjZSB0aGUgcGl4ZWwuIEl0J3Mgbm90IGNsZWFyIHdoaWNoIG9mIHRoZSBhbHBoYSAiY29t cG9uZW50cyIgCmlzIHVzZWQgd2hlbiBhIG1hdGNoIG9jY3VycyBpbiBSR0IgbW9kZS4KClRoZSBj b2xvcmtleSBwcm9wZXJ0eSBpcyBhIHNob3J0Y3V0IHRoYXQgc3RvcmVzIGlkZW50aWNhbCB2YWx1 ZXMgaW4gbWluLCBtYXggCmFuZCB2YWwgYW5kIDAgaW4gYWxwaGEuCgotIGk5MTUKCiNkZWZpbmUg STkxNV9TRVRfQ09MT1JLRVlfTk9ORSAgICAgICAgICAoMTw8MCkKI2RlZmluZSBJOTE1X1NFVF9D T0xPUktFWV9ERVNUSU5BVElPTiAgICgxPDwxKQojZGVmaW5lIEk5MTVfU0VUX0NPTE9SS0VZX1NP VVJDRSAgICAgICAgKDE8PDIpCgpzdHJ1Y3QgZHJtX2ludGVsX3Nwcml0ZV9jb2xvcmtleSB7CiAg ICAgICAgX191MzIgcGxhbmVfaWQ7CiAgICAgICAgX191MzIgbWluX3ZhbHVlOwogICAgICAgIF9f dTMyIGNoYW5uZWxfbWFzazsKICAgICAgICBfX3UzMiBtYXhfdmFsdWU7CiAgICAgICAgX191MzIg ZmxhZ3M7Cn07CgotIG5vdXZlYXUKCiJjb2xvcmtleSIgcmFuZ2UgMHgwMDAwMDAwMCAweDAxZmZm ZmZmCgpUaGUgZm9ybWF0IGlzbid0IGRvY3VtZW50ZWQgYnV0IGl0IHNlZW1zIGZyb20gdGhlIHNv dXJjZSBjb2RlIHRoYXQgYml0cyAyMzowIApzdG9yZSB0aGUgY29sb3Iga2V5IHZhbHVlICh3cml0 dGVuIGRpcmVjdGx5IHRvIGEgcmVnaXN0ZXIsIHNvIHBvc3NpYmx5IGluIGEgCnBpeGVsIGZvcm1h dC1kZXBlbmRlbnQgZm9ybWF0KSBhbmQgYml0IDI0IGVuYWJsZXMgY29sb3Iga2V5aW5nLgoKLSBy Y2FyLWR1CgoiY29sb3JrZXkiIHJhbmdlIDB4MDAwMDAwMDAgMHgwMWZmZmZmZgoKQml0cyAyMzow IHN0b3JlIHRoZSBjb2xvciBrZXkgdmFsdWUgaW4gUkdCODg4IChyZWdhcmRsZXNzIG9mIHRoZSBw aXhlbCBmb3JtYXQgCm9mIHRoZSBwbGFuZSkgYW5kIGJpdCAyNCBlbmFibGVzIGNvbG9yIGtleWlu Zy4gVGhpcyBzdXBwb3J0cyBHZW4yIGhhcmR3YXJlIApvbmx5LCB3aGVyZSB0aGUgb25seSBhdmFp bGFibGUgbW9yZSBpcyAgZXhhY3QgbWF0Y2guIFRoZSBwaXhlbCB0aGVuIGJlY29tZXMgCmZ1bGx5 IHRyYW5zcGFyZW50ICh0aGUgaGFyZHdhcmUgZG9lc24ndCBzdXBwb3J0IGN1c3RvbSB0YXJnZXQg YWxwaGEgdmFsdWVzKS4KCk9uIEdlbjMgaGFyZHdhcmUgY29sb3Iga2V5aW5nIGNhbiBiZSBwZXJm b3JtZWQgaW4gZXhhY3QgUkdCIG1hdGNoLCBleGFjdCBZIAptYXRjaCBvciByYW5nZSBZIG1hdGNo IChvbmx5IHRoZSBtYXggdmFsdWUgaXMgcHJvZ3JhbW1hYmxlLCB0aGUgbWluIHZhbHVlIGlzIAph bHdheXMgMCkuIEZ1cnRoZXJtb3JlIGluIGV4YWN0IG1hdGNoIG1vZGVzIHRoZSBoYXJkd2FyZSBj YW4gb3BlcmF0ZSB3aXRoIGEgCnNpbmdsZSBtYXRjaCB2YWx1ZSwgaW4gd2hpY2ggY2FzZSBpdCBj YW4gdGhlbiBvdmVycmlkZSB0aGUgZnVsbCBBUkdCIG9yIEFZVVYgCnBpeGVsLCBvciBkb3VibGUg bWF0Y2ggdmFsdWUsIGluIHdoaWNoIGNhc2UgaXQgY2FuIHRoZW4gb3ZlcnJpZGUgdGhlIGFscGhh IApjb21wb25lbnQgb25seSwgYnV0IHdpdGggdHdvIGRpc3RpbmN0IG1hdGNoIHZhbHVlcyBlYWNo IGFzc29jaWF0ZWQgd2l0aCBhIAp0YXJnZXQgYWxwaGEuCgotIHZtd2dmeAoKc3RydWN0IGRybV92 bXdfY29udHJvbF9zdHJlYW1fYXJnIHsKICAgICAgICBfX3UzMiBzdHJlYW1faWQ7CiAgICAgICAg X191MzIgZW5hYmxlZDsKCiAgICAgICAgX191MzIgZmxhZ3M7CiAgICAgICAgX191MzIgY29sb3Jf a2V5OwoKICAgICAgICBfX3UzMiBoYW5kbGU7CiAgICAgICAgX191MzIgb2Zmc2V0OwogICAgICAg IF9fczMyIGZvcm1hdDsKICAgICAgICBfX3UzMiBzaXplOwogICAgICAgIF9fdTMyIHdpZHRoOwog ICAgICAgIF9fdTMyIGhlaWdodDsKICAgICAgICBfX3UzMiBwaXRjaFszXTsKCiAgICAgICAgX191 MzIgcGFkNjQ7CiAgICAgICAgc3RydWN0IGRybV92bXdfcmVjdCBzcmM7CiAgICAgICAgc3RydWN0 IGRybV92bXdfcmVjdCBkc3Q7Cn07CgpUaGUgY29sb3Jfa2V5IGZpZWxkIGlzbid0IGRvY3VtZW50 ZWQsIGJ1dCB0aGUgZm9sbG93aW5nICh1bnVzZWQpIG1hY3JvcyBoaW50IAp0aGF0IGl0IGNvdWxk IHN0b3JlIGFuIFJHQjg4OCwgd2l0aCB0aGUgY29sb3Iga2V5IGZlYXR1cmUgZW5hYmxlZCB0aHJv dWdoIHRoZSAKZmxhZ3MgZmllbGQuCgojZGVmaW5lIFNWR0FfVklERU9fRkxBR19DT0xPUktFWSAg ICAgICAgMHgwMDAxCiNkZWZpbmUgU1ZHQV9WSURFT19DT0xPUktFWV9NQVNLICAgICAgICAgICAg IDB4MDBmZmZmZmYKCj4gPj4gRG9lcyB5b3VyIGNvbG9ya2V5IGVuZCB1cCBmb3JjaW5nIGFscGhh IHRvIDEgZm9yIHRoZSBwbGFuZSB3aGVuIGl0J3MKPiA+PiBub3QgbWF0Y2hlZD8KPiAKPiBJIHRo aW5rIHRoaXMgIGJlaGF2aW9yIGlzIEhXIGRlcGVuZGVudCwgb24gUi1DQVIgR2VuMywgdGhlIGFs cGhhIGZvciBwaXhlbAo+IHRoYXQgZG9uJ3QgbWF0Y2ggaXMgbm90IHRvdWNoLgo+IAo+ID4gSSB0 aGluayBnZW5lcmljIGNvbG9yLWtleSBmb3IgcGxhbmUgY29tcG9zaXRpb25pbmcgd291bGQgYmUg bmljZSwgYnV0IEknbQo+ID4gbm90IHN1cmUgdGhhdCdzIHBvc3NpYmxlIGR1ZSB0byBkaWZmZXJl bmNlcyBpbiBob3cgdGhlIGtleSB3b3Jrcy4KPiAKPiBJJ20gdGhpbmtpbmcgb2Ygc3RhcnRpbmcg ZnJvbSB0aGUgZHJpdmVycyB0aGF0IGRvIGhhdmUgdGhpcyBwcm9wZXJ0eSBhbmQgc2VlCj4gaWYg dGhlcmUgaXMgYW55IGNvbW1vbiBncm91bmQgZm9yIGEgZ2VuZXJpYyBjb2xvci1rZXkgcHJvcGVy dHkvaWVzCgpMb29raW5nIGF0IHRoZSA1IGRyaXZlcnMgd2UgaGF2ZSBpbiBtYWlubGluZSB0aGF0 IHN1cHBvcnQgY29sb3Iga2V5aW5nIG9uZSB3YXkgCm9yIGFub3RoZXIsIHdlIGNhbiBhbHJlYWR5 IHNlZSB0aGF0IHRoZSBoYXJkd2FyZSBpbXBsZW1lbnRhdGlvbnMgZGlmZmVyIHF1aXRlIAp3aWRl bHkuIFRoZXJlIGFyZSBob3dldmVyIHNpbWlsYXJpdGllcywgYW5kIHdlIGNvdWxkIGV4cHJlc3Mg bW9zdCBvZiB0aGUgYWJvdmUgCmZlYXR1cmVzIHRocm91Z2ggYSBzZXQgb2YgZ2VuZXJpYyBwcm9w ZXJ0aWVzIHNpbWlsYXIgdG8gdGhlIG9uZXMgYWxyZWFkeSAKaW1wbGVtZW50ZWQgYnkgdGhlIGFy bWFkYSBkcml2ZXIuCgotIFRoZSBtYXRjaCByYW5nZSBjb3VsZCBiZSBzZXQgdGhyb3VnaCBtaW5p bXVtIGFuZCBtYXhpbXVtIHByb3BlcnRpZXMuIERyaXZlcnMgCnRoYXQgc3VwcG9ydCBleGFjdCBt YXRjaCBvbmx5IHdvdWxkIHJlcG9ydCBhbiBlcnJvciB3aXRoIG1pbmltdW0gIT0gbWF4aW11bS4K Ci0gVGhlIHJlcGxhY2VtZW50IHZhbHVlIGNvdWxkIGJlIHNldCB0aHJvdWdoIGEgdmFsdWUgcHJv cGVydHkuIFRoZSBwcm9wZXJ0eSAKY291bGQgc3RvcmUgYm90aCB0aGUgcGl4ZWwgdmFsdWUgKFJH QiBvciBZVVYpIGFuZCB0aGUgYWxwaGEgdmFsdWUsIG9yIHdlIGNvdWxkIApzZXBhcmF0ZSB0aG9z ZSBpbiB0d28gcHJvcGVydGllcy4gV2l0aCBhIHNpbmdsZSBwcm9wZXJ0eSBiaXRzIHRoYXQgYXJl IG5vdCAKYXBwbGljYWJsZSB3b3VsZCBiZSBpZ25vcmVkIChmb3IgaW5zdGFuY2UgUkdCL1lVViBi aXRzIHdoZW4gdGhlIGRyaXZlciAKc3VwcG9ydHMgYWxwaGEgcmVwbGFjZW1lbnQgb25seSkuIElm IHByb2dyYW1tYWJsZSBjb2xvciByZXBsYWNlbWVudCBpc24ndCAKc3VwcG9ydGVkIChhcyBpbiB0 aGUgUi1DYXIgR2VuMiBleGFtcGxlIGFib3ZlKSB0aGUgcHJvcGVydHkgY291bGQgYmUgb21pdHRl ZC4KCi0gVGhlIG1vZGUgY291bGQgYmUgc2V0IHRocm91Z2ggYSBtb2RlIHByb3BlcnR5LiBFbmFi bGluZyBjb2xvciBrZXlpbmcgdGhyb3VnaCAKb25lIGJpdCBpbiBhIGNvbG9yIHByb3BlcnR5IChs aWtlIGRvbmUgYnkgdGhlIG5vdXZlYXUgYW5kIHJjYXItZHUgZHJpdmVycykgaXMgCmEgaGFjayBh bmQgSSBkb24ndCB0aGluayB3ZSBzaG91bGQgY2FycnkgaXQgZm9yd2FyZC4gQSBtb2RlIHByb3Bl cnR5IHdvdWxkIAphbHNvIGFsbG93IGNvbmZpZ3VyaW5nIHNvdXJjZSBvciBkZXN0aW5hdGlvbiBj b2xvciBrZXlpbmcuCgotIFBhcnQgb2YgdGhlIG1vZGUgaW5mb3JtYXRpb24gY291bGQgYmUgZGVk dWNlZCBhdXRvbWF0aWNhbGx5IHdpdGhvdXQgYSBuZWVkIAp0byBzcGVjaWZ5IGl0IGV4cGxpY2l0 bHkuIEZvciBpbnN0YW5jZSBSR0IvWVVWIG1vZGUgY2FuIGJlIGNvbmZpZ3VyZWQgYmFzZWQgb24g CnRoZSBwaXhlbCBmb3JtYXQgb2YgdGhlIHBsYW5lLiBTaW1pbGFybHksIGV4YWN0IG1hdGNoIHZz LiByYW5nZSBtYXRjaCBjYW4gYmUgCmNvbmZpZ3VyZWQgYmFzZWQgb24gd2hldGhlciB0aGUgbWlu aW11bSBhbmQgbWF4aW11bSB2YWx1ZSBkaWZmZXIuCgotIFByb3BlcnRpZXMgdGhhdCBzdG9yZSBw aXhlbCB2YWx1ZXMgY291bGQgZWl0aGVyIGNvbnRhaW4gYSB2YWx1ZSBpbiBhIGZpeGVkIApmb3Jt YXQgKGUuZy4gUkdCODg4KSBvciBpbiBhIGZvcm1hdCB0aGF0IHZhcmllcyBkZXBlbmRpbmcgb24g dGhlIHBpeGVsIGZvcm1hdCAKKGUuZy4gZW5jb2RlZCBpbiB0aGUgc2FtZSBwaXhlbCBmb3JtYXQg YXMgdGhlIHBsYW5lKS4gSSBoYXZlIGEgcHJlZmVyZW5jZSBmb3IgCnRoZSBmb3JtZXIgYnV0IEkn bSBvcGVuIGZvciBkaXNjdXNzaW9ucy4KCi0gV2UgbmVlZCB0byBrZWVwIHRoZSBleGlzdGluZyAi Y29sb3JrZXkiIHByb3BlcnRpZXMgaW1wbGVtZW50ZWQgYnkgYXJtYWRhLCAKbm91dmVhdSBhbmQg cmNhci1kdSBmb3IgYmFja3dhcmQgY29tcGF0aWJpbGl0eSByZWFzb25zLCBidXQgdGhpcyBwcm9w b3NlZCBBUEkgCmRvZXNuJ3QgcmVxdWlyZSBhICJjb2xvcmtleSIgcHJvcGVydHkuIFdlIGNvdWxk IGhvd2V2ZXIgZGVjaWRlIHRvIHN0YW5kYXJkaXplIAphICJjb2xvcmtleSIgcHJvcGVydHkgYXMg YSBzaG9ydGN1dCBzaW1pbGFyIHRvIHdoYXQgdGhlIGFybWFkYSBkcml2ZXIgZG9lcy4KCgpTb21l IG9mIHRoZSBSLUNhciBHZW4zIGhhcmR3YXJlIGZlYXR1cmVzIHdvdWxkbid0IGJlIHN1cHBvcnRl ZCBieSB0aGUgYWJvdmUgCnByb3Bvc2FsLiBTZWxlY3RpbmcgZXhhY3QgbWF0Y2ggdnMuIHJhbmdl IG1hdGNoIHNob3VsZCBiZSBmaW5lLCB3aXRoIGF0b21pYyAKY29tbWl0IHJldHVybmluZyBhbiBl cnJvciBpZiBtaW5pbXVtICE9IDAgJiYgbWluaW11bSAhPSBtYXhpbXVtLiBUaGUgZHVhbCAKdGFy Z2V0IG1vZGUsIGhvd2V2ZXIsIGNhbid0IHJlYWxseSBmaXQgdGhlIHByb3BlcnRpZXMgcHJvcG9z ZWQgaGVyZS4gSSBkb24ndCAKaGF2ZSBhIHVzZSBjYXNlIGZvciB0aGF0IG1vZGUgYXQgdGhlIG1v bWVudCBidXQgSSdtIGZhaXJseSBjZXJ0YWluIHRoYXQgCnNvbWVvbmUgd2lsbCBjb21lIHVwIHdp dGggb25lLCBhdCBsZWFzdCBpZiBub3QgZm9yIHRoZSBSLUNhciBmb3IgYSBkaWZmZXJlbnQgCmRp c3BsYXkgZW5naW5lIHRoYXQgcHJvdmlkZXMgc2ltaWxhcmx5IGV4b3RpYyBmZWF0dXJlcy4KCldl IGNvdWxkIGFsc28gZGVjaWRlIHRvIHN0YW5kYXJkaXplIHRoZSBjb2xvciBrZXlpbmcgcHJvcGVy dGllcyBpbiBhIHdheSB0aGF0IAp3b3VsZCBiYWxhbmNlIGNvbXBsZXhpdHkgdnMuIGhhcmR3YXJl IGZlYXR1cmVzIHN1cHBvcnQsIGFuZCBsZXQgZHJpdmVycyB0aGF0IApuZWVkIGV4b3RpYyBmZWF0 dXJlcyBpbXBsZW1lbnQgYWRkaXRpb25hbCBwcm9wZXJ0aWVzLgoKSWRlYXMgYW5kIGNvbW1lbnRz IGFyZSB3ZWxjb21lLCBJJ2QgbGlrZSB0byBzdGFydCB3b3JraW5nIG9uIHRoaXMgZmFpcmx5IHNv b24uCgotLSAKUmVnYXJkcywKCkxhdXJlbnQgUGluY2hhcnQKCl9fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRl dmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9t YWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=