From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from galahad.ideasonboard.com ([185.26.127.97]:50475 "EHLO galahad.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751512AbdLQARU (ORCPT ); Sat, 16 Dec 2017 19:17:20 -0500 From: Laurent Pinchart To: dri-devel@lists.freedesktop.org Cc: linux-media@vger.kernel.org, linux-renesas-soc@vger.kernel.org, Alexandru Gheorghe , Russell King , Ben Skeggs , Sinclair Yeh , Thomas Hellstrom , Jani Nikula , Joonas Lahtinen , Rodrigo Vivi Subject: [PATCH/RFC 0/4] Implement standard color keying properties Date: Sun, 17 Dec 2017 02:17:20 +0200 Message-Id: <20171217001724.1348-1-laurent.pinchart+renesas@ideasonboard.com> Sender: linux-media-owner@vger.kernel.org List-ID: Hello, This patch series is an attempt at implementing standard properties for color keying support in the KMS API. Before designing the API proposal I've analyzed the KMS drivers that support color keying in the upstream kernel. Part of the explanation below was initially posted in a reply to "[PATCH v2 0/2] rcar-du, vsp1: rcar-gen3: Add support for colorkey alpha blending" and is copied here to continue the discussion. The armada, nouveau and rcar-du drivers expose the color key through DRM properties. The i915 and vmwgfx drivers use custom ioctls. Here is how they currently implement color keying. - 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 Looking at these drivers 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. This is what the patch series attempts to do. - The match range can be set through minimum and maximum properties. Drivers that support exact match only simply report an error when minimum != maximum. - The replacement value can be set through a value property. The property stores both the pixel value (RGB or YUV) and the alpha value Bits that are not applicable are 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 is omitted. - The mode can 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 allows 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. - The modes exposed through the mode property are left as driver-specific in this RFC, with one "disabled" mode mandatory for all implementations. The rationale is that a generic userspace should be able to disable color keying, but that hardware features vary too much to standardize all modes. I'm however starting to think that we should standardize more modes than "disabled", but I still need to sleep over this particular issue. Ideas and comments are welcome. - Properties that store pixel values store them in a fixed AXYZ16161616 format where A is the alpha value and XYZ color components that correspond to the plane pixel format (usually RGB or YUV). - 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. I have reimplemented the existing "colorkey" in the rcar-du driver as an alias for the new standard properties to show how it can be done in a driver. The R-Car Gen3 dual target mode feature doesn't fit in the properties proposed here. I have no 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. I believe this can for now be left for implementation through driver-specific properties. Alexandru Gheorghe (1): v4l: vsp1: Add support for colorkey alpha blending Laurent Pinchart (3): drm: Add colorkey properties drm: rcar-du: Use standard colorkey properties drm: rcar-du: Add support for color keying on Gen3 drivers/gpu/drm/drm_atomic.c | 16 +++++ drivers/gpu/drm/drm_blend.c | 108 ++++++++++++++++++++++++++++++++ drivers/gpu/drm/rcar-du/rcar_du_plane.c | 60 +++++++++++++----- drivers/gpu/drm/rcar-du/rcar_du_plane.h | 2 - drivers/gpu/drm/rcar-du/rcar_du_vsp.c | 17 ++++- drivers/media/platform/vsp1/vsp1_drm.c | 3 + drivers/media/platform/vsp1/vsp1_rpf.c | 10 ++- drivers/media/platform/vsp1/vsp1_rwpf.h | 5 ++ include/drm/drm_blend.h | 4 ++ include/drm/drm_plane.h | 28 ++++++++- include/media/vsp1.h | 5 ++ 11 files changed, 235 insertions(+), 23 deletions(-) -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: [PATCH/RFC 0/4] Implement standard color keying properties Date: Sun, 17 Dec 2017 02:17:20 +0200 Message-ID: <20171217001724.1348-1-laurent.pinchart+renesas@ideasonboard.com> 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 [IPv6:2001:4b98:dc2:45:216:3eff:febb:480d]) by gabe.freedesktop.org (Postfix) with ESMTPS id 7FB696E11E for ; Sun, 17 Dec 2017 00:17:20 +0000 (UTC) List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: dri-devel@lists.freedesktop.org Cc: Thomas Hellstrom , Joonas Lahtinen , Russell King , linux-renesas-soc@vger.kernel.org, Ben Skeggs , Rodrigo Vivi , Alexandru Gheorghe , linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org SGVsbG8sCgpUaGlzIHBhdGNoIHNlcmllcyBpcyBhbiBhdHRlbXB0IGF0IGltcGxlbWVudGluZyBz dGFuZGFyZCBwcm9wZXJ0aWVzIGZvciBjb2xvcgprZXlpbmcgc3VwcG9ydCBpbiB0aGUgS01TIEFQ SS4KCkJlZm9yZSBkZXNpZ25pbmcgdGhlIEFQSSBwcm9wb3NhbCBJJ3ZlIGFuYWx5emVkIHRoZSBL TVMgZHJpdmVycyB0aGF0IHN1cHBvcnQKY29sb3Iga2V5aW5nIGluIHRoZSB1cHN0cmVhbSBrZXJu ZWwuIFBhcnQgb2YgdGhlIGV4cGxhbmF0aW9uIGJlbG93IHdhcwppbml0aWFsbHkgcG9zdGVkIGlu IGEgcmVwbHkgdG8gIltQQVRDSCB2MiAwLzJdIHJjYXItZHUsIHZzcDE6IHJjYXItZ2VuMzogQWRk CnN1cHBvcnQgZm9yIGNvbG9ya2V5IGFscGhhIGJsZW5kaW5nIiBhbmQgaXMgY29waWVkIGhlcmUg dG8gY29udGludWUgdGhlCmRpc2N1c3Npb24uCgpUaGUgYXJtYWRhLCBub3V2ZWF1IGFuZCByY2Fy LWR1IGRyaXZlcnMgZXhwb3NlIHRoZSBjb2xvciBrZXkgdGhyb3VnaCBEUk0KcHJvcGVydGllcy4g VGhlIGk5MTUgYW5kIHZtd2dmeCBkcml2ZXJzIHVzZSBjdXN0b20gaW9jdGxzLiBIZXJlIGlzIGhv dyB0aGV5CmN1cnJlbnRseSBpbXBsZW1lbnQgY29sb3Iga2V5aW5nLgoKLSBhcm1hZGEKCiJjb2xv cmtleSIgcmFuZ2UgIDB4MDAwMDAwMDAgMHgwMGZmZmZmZgoiY29sb3JrZXlfbWluIiByYW5nZSAg MHgwMDAwMDAwMCAweDAwZmZmZmZmCiJjb2xvcmtleV9tYXgiIHJhbmdlICAweDAwMDAwMDAwIDB4 MDBmZmZmZmYKImNvbG9ya2V5X3ZhbCIgcmFuZ2UgIDB4MDAwMDAwMDAgMHgwMGZmZmZmZgoiY29s b3JrZXlfYWxwaGEiIHJhbmdlICAweDAwMDAwMDAwIDB4MDBmZmZmZmYKImNvbG9ya2V5X21vZGUi IGVudW0gImRpc2FibGUiLCAiWSBjb21wb25lbnQiLCAiVSBjb21wb25lbnQiLCAiViBjb21wb25l bnQiLCAKIlJHQiIsICJSIGNvbXBvbmVudCIsICJHIGNvbXBvbmVudCIsICJCIGNvbXBvbmVudCIK CkFsbCByYW5nZSBwcm9wZXJ0aWVzIHN0b3JlIGEgUkdCODg4IG9yIFlVVjg4OCB0cmlwbGV0LgoK VGhlIG1pbiBhbmQgbWF4IHByb3BlcnRpZXMgc3RvcmUgdGhlIGNvbXBhcmlzb24gcmFuZ2VzLiBX aGVuIGEgbWF0Y2ggb2NjdXJzIApmb3Igb25lIG9mIHRoZSBjb21wb25lbnRzLCB0aGUgdmFsdWUg YW5kIGFscGhhIGZyb20gdGhlIHZhbCBhbmQgYWxwaGEgCnByb3BlcnRpZXMgcmVwbGFjZSB0aGUg cGl4ZWwuIEl0J3Mgbm90IGNsZWFyIHdoaWNoIG9mIHRoZSBhbHBoYSAiY29tcG9uZW50cyIgCmlz IHVzZWQgd2hlbiBhIG1hdGNoIG9jY3VycyBpbiBSR0IgbW9kZS4KClRoZSBjb2xvcmtleSBwcm9w ZXJ0eSBpcyBhIHNob3J0Y3V0IHRoYXQgc3RvcmVzIGlkZW50aWNhbCB2YWx1ZXMgaW4gbWluLCBt YXggCmFuZCB2YWwgYW5kIDAgaW4gYWxwaGEuCgotIGk5MTUKCiNkZWZpbmUgSTkxNV9TRVRfQ09M T1JLRVlfTk9ORSAgICAgICAgICAoMTw8MCkKI2RlZmluZSBJOTE1X1NFVF9DT0xPUktFWV9ERVNU SU5BVElPTiAgICgxPDwxKQojZGVmaW5lIEk5MTVfU0VUX0NPTE9SS0VZX1NPVVJDRSAgICAgICAg KDE8PDIpCgpzdHJ1Y3QgZHJtX2ludGVsX3Nwcml0ZV9jb2xvcmtleSB7CiAgICAgICAgX191MzIg cGxhbmVfaWQ7CiAgICAgICAgX191MzIgbWluX3ZhbHVlOwogICAgICAgIF9fdTMyIGNoYW5uZWxf bWFzazsKICAgICAgICBfX3UzMiBtYXhfdmFsdWU7CiAgICAgICAgX191MzIgZmxhZ3M7Cn07Cgot IG5vdXZlYXUKCiJjb2xvcmtleSIgcmFuZ2UgMHgwMDAwMDAwMCAweDAxZmZmZmZmCgpUaGUgZm9y bWF0IGlzbid0IGRvY3VtZW50ZWQgYnV0IGl0IHNlZW1zIGZyb20gdGhlIHNvdXJjZSBjb2RlIHRo YXQgYml0cyAyMzowIApzdG9yZSB0aGUgY29sb3Iga2V5IHZhbHVlICh3cml0dGVuIGRpcmVjdGx5 IHRvIGEgcmVnaXN0ZXIsIHNvIHBvc3NpYmx5IGluIGEgCnBpeGVsIGZvcm1hdC1kZXBlbmRlbnQg Zm9ybWF0KSBhbmQgYml0IDI0IGVuYWJsZXMgY29sb3Iga2V5aW5nLgoKLSByY2FyLWR1CgoiY29s b3JrZXkiIHJhbmdlIDB4MDAwMDAwMDAgMHgwMWZmZmZmZgoKQml0cyAyMzowIHN0b3JlIHRoZSBj b2xvciBrZXkgdmFsdWUgaW4gUkdCODg4IChyZWdhcmRsZXNzIG9mIHRoZSBwaXhlbCBmb3JtYXQg Cm9mIHRoZSBwbGFuZSkgYW5kIGJpdCAyNCBlbmFibGVzIGNvbG9yIGtleWluZy4gVGhpcyBzdXBw b3J0cyBHZW4yIGhhcmR3YXJlIApvbmx5LCB3aGVyZSB0aGUgb25seSBhdmFpbGFibGUgbW9yZSBp cyAgZXhhY3QgbWF0Y2guIFRoZSBwaXhlbCB0aGVuIGJlY29tZXMgCmZ1bGx5IHRyYW5zcGFyZW50 ICh0aGUgaGFyZHdhcmUgZG9lc24ndCBzdXBwb3J0IGN1c3RvbSB0YXJnZXQgYWxwaGEgdmFsdWVz KS4KCk9uIEdlbjMgaGFyZHdhcmUgY29sb3Iga2V5aW5nIGNhbiBiZSBwZXJmb3JtZWQgaW4gZXhh Y3QgUkdCIG1hdGNoLCBleGFjdCBZIAptYXRjaCBvciByYW5nZSBZIG1hdGNoIChvbmx5IHRoZSBt YXggdmFsdWUgaXMgcHJvZ3JhbW1hYmxlLCB0aGUgbWluIHZhbHVlIGlzIAphbHdheXMgMCkuIEZ1 cnRoZXJtb3JlIGluIGV4YWN0IG1hdGNoIG1vZGVzIHRoZSBoYXJkd2FyZSBjYW4gb3BlcmF0ZSB3 aXRoIGEgCnNpbmdsZSBtYXRjaCB2YWx1ZSwgaW4gd2hpY2ggY2FzZSBpdCBjYW4gdGhlbiBvdmVy cmlkZSB0aGUgZnVsbCBBUkdCIG9yIEFZVVYgCnBpeGVsLCBvciBkb3VibGUgbWF0Y2ggdmFsdWUs IGluIHdoaWNoIGNhc2UgaXQgY2FuIHRoZW4gb3ZlcnJpZGUgdGhlIGFscGhhIApjb21wb25lbnQg b25seSwgYnV0IHdpdGggdHdvIGRpc3RpbmN0IG1hdGNoIHZhbHVlcyBlYWNoIGFzc29jaWF0ZWQg d2l0aCBhIAp0YXJnZXQgYWxwaGEuCgotIHZtd2dmeAoKc3RydWN0IGRybV92bXdfY29udHJvbF9z dHJlYW1fYXJnIHsKICAgICAgICBfX3UzMiBzdHJlYW1faWQ7CiAgICAgICAgX191MzIgZW5hYmxl ZDsKCiAgICAgICAgX191MzIgZmxhZ3M7CiAgICAgICAgX191MzIgY29sb3Jfa2V5OwoKICAgICAg ICBfX3UzMiBoYW5kbGU7CiAgICAgICAgX191MzIgb2Zmc2V0OwogICAgICAgIF9fczMyIGZvcm1h dDsKICAgICAgICBfX3UzMiBzaXplOwogICAgICAgIF9fdTMyIHdpZHRoOwogICAgICAgIF9fdTMy IGhlaWdodDsKICAgICAgICBfX3UzMiBwaXRjaFszXTsKCiAgICAgICAgX191MzIgcGFkNjQ7CiAg ICAgICAgc3RydWN0IGRybV92bXdfcmVjdCBzcmM7CiAgICAgICAgc3RydWN0IGRybV92bXdfcmVj dCBkc3Q7Cn07CgpUaGUgY29sb3Jfa2V5IGZpZWxkIGlzbid0IGRvY3VtZW50ZWQsIGJ1dCB0aGUg Zm9sbG93aW5nICh1bnVzZWQpIG1hY3JvcyBoaW50IAp0aGF0IGl0IGNvdWxkIHN0b3JlIGFuIFJH Qjg4OCwgd2l0aCB0aGUgY29sb3Iga2V5IGZlYXR1cmUgZW5hYmxlZCB0aHJvdWdoIHRoZSAKZmxh Z3MgZmllbGQuCgojZGVmaW5lIFNWR0FfVklERU9fRkxBR19DT0xPUktFWSAgICAgICAgMHgwMDAx CiNkZWZpbmUgU1ZHQV9WSURFT19DT0xPUktFWV9NQVNLICAgICAgICAgICAgIDB4MDBmZmZmZmYK Ckxvb2tpbmcgYXQgdGhlc2UgZHJpdmVycyB3ZSBjYW4gYWxyZWFkeSBzZWUgdGhhdCB0aGUgaGFy ZHdhcmUgaW1wbGVtZW50YXRpb25zCmRpZmZlciBxdWl0ZSB3aWRlbHkuIFRoZXJlIGFyZSBob3dl dmVyIHNpbWlsYXJpdGllcywgYW5kIHdlIGNvdWxkIGV4cHJlc3MgbW9zdApvZiB0aGUgYWJvdmUg ZmVhdHVyZXMgdGhyb3VnaCBhIHNldCBvZiBnZW5lcmljIHByb3BlcnRpZXMgc2ltaWxhciB0byB0 aGUgb25lcwphbHJlYWR5IGltcGxlbWVudGVkIGJ5IHRoZSBhcm1hZGEgZHJpdmVyLiBUaGlzIGlz IHdoYXQgdGhlIHBhdGNoIHNlcmllcwphdHRlbXB0cyB0byBkby4KCi0gVGhlIG1hdGNoIHJhbmdl IGNhbiBiZSBzZXQgdGhyb3VnaCBtaW5pbXVtIGFuZCBtYXhpbXVtIHByb3BlcnRpZXMuIERyaXZl cnMKdGhhdCBzdXBwb3J0IGV4YWN0IG1hdGNoIG9ubHkgc2ltcGx5IHJlcG9ydCBhbiBlcnJvciB3 aGVuIG1pbmltdW0gIT0gbWF4aW11bS4KCi0gVGhlIHJlcGxhY2VtZW50IHZhbHVlIGNhbiBiZSBz ZXQgdGhyb3VnaCBhIHZhbHVlIHByb3BlcnR5LiBUaGUgcHJvcGVydHkKc3RvcmVzIGJvdGggdGhl IHBpeGVsIHZhbHVlIChSR0Igb3IgWVVWKSBhbmQgdGhlIGFscGhhIHZhbHVlIEJpdHMgdGhhdCBh cmUgbm90CmFwcGxpY2FibGUgYXJlIGlnbm9yZWQgKGZvciBpbnN0YW5jZSBSR0IvWVVWIGJpdHMg d2hlbiB0aGUgZHJpdmVyIHN1cHBvcnRzCmFscGhhIHJlcGxhY2VtZW50IG9ubHkpLiBJZiBwcm9n cmFtbWFibGUgY29sb3IgcmVwbGFjZW1lbnQgaXNuJ3Qgc3VwcG9ydGVkIChhcwppbiB0aGUgUi1D YXIgR2VuMiBleGFtcGxlIGFib3ZlKSB0aGUgcHJvcGVydHkgaXMgb21pdHRlZC4KCi0gVGhlIG1v ZGUgY2FuIGJlIHNldCB0aHJvdWdoIGEgbW9kZSBwcm9wZXJ0eS4gRW5hYmxpbmcgY29sb3Iga2V5 aW5nIHRocm91Z2gKb25lIGJpdCBpbiBhIGNvbG9yIHByb3BlcnR5IChsaWtlIGRvbmUgYnkgdGhl IG5vdXZlYXUgYW5kIHJjYXItZHUgZHJpdmVycykgaXMgCmEgaGFjayBhbmQgSSBkb24ndCB0aGlu ayB3ZSBzaG91bGQgY2FycnkgaXQgZm9yd2FyZC4gQSBtb2RlIHByb3BlcnR5IGFsbG93cwpjb25m aWd1cmluZyBzb3VyY2Ugb3IgZGVzdGluYXRpb24gY29sb3Iga2V5aW5nLgoKLSBQYXJ0IG9mIHRo ZSBtb2RlIGluZm9ybWF0aW9uIGNvdWxkIGJlIGRlZHVjZWQgYXV0b21hdGljYWxseSB3aXRob3V0 IGEgbmVlZAp0byBzcGVjaWZ5IGl0IGV4cGxpY2l0bHkuIEZvciBpbnN0YW5jZSBSR0IvWVVWIG1v ZGUgY2FuIGJlIGNvbmZpZ3VyZWQgYmFzZWQgb24KdGhlIHBpeGVsIGZvcm1hdCBvZiB0aGUgcGxh bmUuIFNpbWlsYXJseSwgZXhhY3QgbWF0Y2ggdnMuIHJhbmdlIG1hdGNoIGNhbiBiZQpjb25maWd1 cmVkIGJhc2VkIG9uIHdoZXRoZXIgdGhlIG1pbmltdW0gYW5kIG1heGltdW0gdmFsdWUgZGlmZmVy LgoKLSBUaGUgbW9kZXMgZXhwb3NlZCB0aHJvdWdoIHRoZSBtb2RlIHByb3BlcnR5IGFyZSBsZWZ0 IGFzIGRyaXZlci1zcGVjaWZpYyBpbgp0aGlzIFJGQywgd2l0aCBvbmUgImRpc2FibGVkIiBtb2Rl IG1hbmRhdG9yeSBmb3IgYWxsIGltcGxlbWVudGF0aW9ucy4gVGhlCnJhdGlvbmFsZSBpcyB0aGF0 IGEgZ2VuZXJpYyB1c2Vyc3BhY2Ugc2hvdWxkIGJlIGFibGUgdG8gZGlzYWJsZSBjb2xvciBrZXlp bmcsCmJ1dCB0aGF0IGhhcmR3YXJlIGZlYXR1cmVzIHZhcnkgdG9vIG11Y2ggdG8gc3RhbmRhcmRp emUgYWxsIG1vZGVzLiBJJ20gaG93ZXZlcgpzdGFydGluZyB0byB0aGluayB0aGF0IHdlIHNob3Vs ZCBzdGFuZGFyZGl6ZSBtb3JlIG1vZGVzIHRoYW4gImRpc2FibGVkIiwgYnV0IEkKc3RpbGwgbmVl ZCB0byBzbGVlcCBvdmVyIHRoaXMgcGFydGljdWxhciBpc3N1ZS4gSWRlYXMgYW5kIGNvbW1lbnRz IGFyZQp3ZWxjb21lLgoKLSBQcm9wZXJ0aWVzIHRoYXQgc3RvcmUgcGl4ZWwgdmFsdWVzIHN0b3Jl IHRoZW0gaW4gYSBmaXhlZCBBWFlaMTYxNjE2MTYgZm9ybWF0CndoZXJlIEEgaXMgdGhlIGFscGhh IHZhbHVlIGFuZCBYWVogY29sb3IgY29tcG9uZW50cyB0aGF0IGNvcnJlc3BvbmQgdG8gdGhlCnBs YW5lIHBpeGVsIGZvcm1hdCAodXN1YWxseSBSR0Igb3IgWVVWKS4KCi0gV2UgbmVlZCB0byBrZWVw IHRoZSBleGlzdGluZyAiY29sb3JrZXkiIHByb3BlcnRpZXMgaW1wbGVtZW50ZWQgYnkgYXJtYWRh LCAKbm91dmVhdSBhbmQgcmNhci1kdSBmb3IgYmFja3dhcmQgY29tcGF0aWJpbGl0eSByZWFzb25z LCBidXQgdGhpcyBwcm9wb3NlZCBBUEkgCmRvZXNuJ3QgcmVxdWlyZSBhICJjb2xvcmtleSIgcHJv cGVydHkuIEkgaGF2ZSByZWltcGxlbWVudGVkIHRoZSBleGlzdGluZwoiY29sb3JrZXkiIGluIHRo ZSByY2FyLWR1IGRyaXZlciBhcyBhbiBhbGlhcyBmb3IgdGhlIG5ldyBzdGFuZGFyZCBwcm9wZXJ0 aWVzCnRvIHNob3cgaG93IGl0IGNhbiBiZSBkb25lIGluIGEgZHJpdmVyLgoKClRoZSBSLUNhciBH ZW4zIGR1YWwgdGFyZ2V0IG1vZGUgZmVhdHVyZSBkb2Vzbid0IGZpdCBpbiB0aGUgcHJvcGVydGll cyBwcm9wb3NlZApoZXJlLiBJIGhhdmUgbm8gdXNlIGNhc2UgZm9yIHRoYXQgbW9kZSBhdCB0aGUg bW9tZW50IGJ1dCBJJ20gZmFpcmx5IGNlcnRhaW4KdGhhdCBzb21lb25lIHdpbGwgY29tZSB1cCB3 aXRoIG9uZSwgYXQgbGVhc3QgaWYgbm90IGZvciB0aGUgUi1DYXIgZm9yIGEKZGlmZmVyZW50IGRp c3BsYXkgZW5naW5lIHRoYXQgcHJvdmlkZXMgc2ltaWxhcmx5IGV4b3RpYyBmZWF0dXJlcy4gSSBi ZWxpZXZlCnRoaXMgY2FuIGZvciBub3cgYmUgbGVmdCBmb3IgaW1wbGVtZW50YXRpb24gdGhyb3Vn aCBkcml2ZXItc3BlY2lmaWMKcHJvcGVydGllcy4KCkFsZXhhbmRydSBHaGVvcmdoZSAoMSk6CiAg djRsOiB2c3AxOiBBZGQgc3VwcG9ydCBmb3IgY29sb3JrZXkgYWxwaGEgYmxlbmRpbmcKCkxhdXJl bnQgUGluY2hhcnQgKDMpOgogIGRybTogQWRkIGNvbG9ya2V5IHByb3BlcnRpZXMKICBkcm06IHJj YXItZHU6IFVzZSBzdGFuZGFyZCBjb2xvcmtleSBwcm9wZXJ0aWVzCiAgZHJtOiByY2FyLWR1OiBB ZGQgc3VwcG9ydCBmb3IgY29sb3Iga2V5aW5nIG9uIEdlbjMKCiBkcml2ZXJzL2dwdS9kcm0vZHJt X2F0b21pYy5jICAgICAgICAgICAgfCAgMTYgKysrKysKIGRyaXZlcnMvZ3B1L2RybS9kcm1fYmxl bmQuYyAgICAgICAgICAgICB8IDEwOCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwog ZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9wbGFuZS5jIHwgIDYwICsrKysrKysrKysr KystLS0tLQogZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9wbGFuZS5oIHwgICAyIC0K IGRyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfdnNwLmMgICB8ICAxNyArKysrLQogZHJp dmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZHJtLmMgIHwgICAzICsKIGRyaXZlcnMvbWVk aWEvcGxhdGZvcm0vdnNwMS92c3AxX3JwZi5jICB8ICAxMCArKy0KIGRyaXZlcnMvbWVkaWEvcGxh dGZvcm0vdnNwMS92c3AxX3J3cGYuaCB8ICAgNSArKwogaW5jbHVkZS9kcm0vZHJtX2JsZW5kLmgg ICAgICAgICAgICAgICAgIHwgICA0ICsrCiBpbmNsdWRlL2RybS9kcm1fcGxhbmUuaCAgICAgICAg ICAgICAgICAgfCAgMjggKysrKysrKystCiBpbmNsdWRlL21lZGlhL3ZzcDEuaCAgICAgICAgICAg ICAgICAgICAgfCAgIDUgKysKIDExIGZpbGVzIGNoYW5nZWQsIDIzNSBpbnNlcnRpb25zKCspLCAy MyBkZWxldGlvbnMoLSkKCi0tIApSZWdhcmRzLAoKTGF1cmVudCBQaW5jaGFydAoKX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcg bGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRl c2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==