From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from lb3-smtp-cloud7.xs4all.net ([194.109.24.31]:42449 "EHLO lb3-smtp-cloud7.xs4all.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726165AbeIJNHW (ORCPT ); Mon, 10 Sep 2018 09:07:22 -0400 Subject: Re: [Xen-devel][PATCH 1/1] cameraif: add ABI for para-virtual camera To: Oleksandr Andrushchenko , Juergen Gross , xen-devel@lists.xenproject.org, konrad.wilk@oracle.com, boris.ostrovsky@oracle.com, mchehab@kernel.org, linux-media@vger.kernel.org, sakari.ailus@linux.intel.com, koji.matsuoka.xm@renesas.com Cc: Oleksandr Andrushchenko , Artem Mygaiev References: <20180731093142.3828-1-andr2000@gmail.com> <20180731093142.3828-2-andr2000@gmail.com> <99cd131d-85ae-bbfb-61ef-fdc0401727f6@suse.com> <5505e5af-5b64-b317-a0d8-09c11317926f@gmail.com> <345d7ec3-3ca3-e8fe-28a0-ba299196b5e4@gmail.com> <53189190-ffe0-9795-b01c-01de8db83acb@gmail.com> <641cd785-c5e7-7552-dc4b-35249f1f1985@xs4all.nl> From: Hans Verkuil Message-ID: Date: Mon, 10 Sep 2018 10:14:28 +0200 MIME-Version: 1.0 In-Reply-To: Content-Type: text/plain; charset=utf-8 Content-Language: en-US Content-Transfer-Encoding: 7bit Sender: linux-media-owner@vger.kernel.org List-ID: On 09/10/2018 07:59 AM, Oleksandr Andrushchenko wrote: > Hi, Hans! > > On 09/09/2018 01:42 PM, Hans Verkuil wrote: >> On 09/04/2018 08:56 AM, Oleksandr Andrushchenko wrote: >>> On 09/03/2018 06:25 PM, Hans Verkuil wrote: >>>> Hi Oleksandr, >>>> >>>> On 09/03/2018 12:16 PM, Oleksandr Andrushchenko wrote: >>>>> On 08/21/2018 08:54 AM, Oleksandr Andrushchenko wrote: >>>>>> On 08/14/2018 11:30 AM, Juergen Gross wrote: >>>>>>> On 31/07/18 11:31, Oleksandr Andrushchenko wrote: >>>>>>>> From: Oleksandr Andrushchenko >>>>>>>> >>>>>>>> This is the ABI for the two halves of a para-virtualized >>>>>>>> camera driver which extends Xen's reach multimedia capabilities even >>>>>>>> farther enabling it for video conferencing, In-Vehicle Infotainment, >>>>>>>> high definition maps etc. >>>>>>>> >>>>>>>> The initial goal is to support most needed functionality with the >>>>>>>> final idea to make it possible to extend the protocol if need be: >>>>>>>> >>>>>>>> 1. Provide means for base virtual device configuration: >>>>>>>> - pixel formats >>>>>>>> - resolutions >>>>>>>> - frame rates >>>>>>>> 2. Support basic camera controls: >>>>>>>> - contrast >>>>>>>> - brightness >>>>>>>> - hue >>>>>>>> - saturation >>>>>>>> 3. Support streaming control >>>>>>>> 4. Support zero-copying use-cases >>>>>>>> >>>>>>>> Signed-off-by: Oleksandr Andrushchenko >>>>>>>> >>>>>>> Some style issues below... >>>>>> Will fix all the below, thank you! >>>>>> >>>>>> I would like to draw some attention of the Linux/V4L community to this >>>>>> protocol as the plan is that once it is accepted for Xen we plan to >>>>>> upstream a Linux camera front-end kernel driver which will be based >>>>>> on this work and will be a V4L2 device driver (this is why I have sent >>>>>> this patch not only to Xen, but to the corresponding Linux mailing list >>>>>> as well) >>>>> ping >>>> Sorry, this got buried in my mailbox, I only came across it today. I'll try >>>> to review this this week, if not, just ping me again. >>> Thank you for your time >>>> I had one high-level question, though: >>>> >>>> What types of hardware do you intend to target? This initial version targets >>>> (very) simple webcams, but what about HDMI or SDTV receivers? Or hardware >>>> codecs? Or complex embedded video pipelines? >>>> >>>> In other words, where are you planning to draw the line? >>>> >>>> Even with just simple cameras there is a difference between regular UVC >>>> webcams and cameras used with embedded systems: for the latter you often >>>> need to provide more control w.r.t. white-balancing etc., things that a >>>> UVC webcam will generally do for you in the webcam's firmware. >>> The use-cases we want to implement are mostly in automotive/embedded domain, >>> so there are many performance restrictions apply. >>> We are not targeting virtualizing very complex hardware and have no >>> intention >>> to make a 1:1 mapping of the real hardware: for that one can pass-through >>> a real HW device to a virtual machine (VM). The goal is to share a single >>> camera device to multiple virtual machines, no codecs, receivers etc. >>> >>> Controlling the same HW device from different VMs doesn't look feasible: >>> what if the same control is set to different values from different VMs? >> You can do this, actually: in V4L2 you can get an event when another process >> changes a control, and update your own GUI/internal state accordingly. >> >> So in this case if one VM changes a control, an event is sent to all others >> that the control has changed value. > Well, technically this can be done by introducing one more > event for such a notification. But, from system partitioning > POV, I am still not convinced this should be done: I would prefer > that a single VM owns such a control and even which control and which > VM is decided while configuring the whole system. > So, I would like to keep it as is. Well, I am not convinced you can avoid this: some controls are set by drivers when something happens and so applications will subscribe to the control and wait for changes in their values. While this is for more advanced use-cases (certainly more than what you propose today), I would suggest that it is wise to at least think on how this can be added in the future. Controls and control events are a key part of V4L2. >> >>> Of course, this can be achieved if the corresponding backend can >>> post-process >>> original camera image with GPU, for example, thus applying different filters >>> for different VMs effectively emulating camera controls. >>> But this requires additional CPU/GPU power which we try to avoid. >>> >>> System partitioning (camera and controls assignment) is done at >>> configuration >>> time (remember we are in automotive/embedded world, so most of the time >>> the set >>> of VMs requiring cameras is known at this stage and the configuration >>> remains >>> static at run-time). So, when para-virtualized (PV) approach is used then we >>> only implement very basic controls (those found in the protocol), so one can >>> assign set of controls (all or some) to one of the VMs (main or mission >>> critical >>> VM or whatever) allowing that VM to adjusts those for all VMs at once. >>> For other >>> VMs think of it as firmware implemented adjustment. And the backend still >>> controls the rest of the controls of the real HW camera you mention. >>> >>> Just an example of automotive use-case (we can imagine many more): >>> 1. Driver Domain - owns real camera HW and runs the camera backend. >>> Uses camera output for mission critical tasks, e.g. parking assistance. >>> 2. In-Vehicle Infotainment domain - uses PV camera for infotainment >>> purposes, >>> e.g. taking pictures while in motion. >>> 3. Navigation domain - uses PV camera for high definition maps >>> >>> Hope, this helps understanding the possible uses of the proposed >>> protocol, its >>> intention and restrictions. >> Right, so in this scenario you probably do not want hotpluggable >> sources in the Driver Domain. So support for fixed camera's only. > Well, some sort of hotplug can already be implemented, please > see [1], [2] as it is done for virtual display: this is > achieved as a response to the backend's state change, > e.g. whenever backend decides to unplug the virtual device > it changes its state accordingly. >> >> If this is indeed the case, then this should be made very clear in >> the API specification. > As I described above this is already assumed by the state > machine of a xenbus_driver >> One additional thing to consider: cameras can break. So what should be >> done if that happens? We as media developers have ideas about that, but >> nothing has been implemented (yet). >> >> If the HW is simple (one camera is driven by a single driver instance), >> then if it breaks, there simply won't be a video device. But if you have >> multiple cameras all controlled through the same driver instance, then today >> if a single camera breaks, all are gone. > Please see above I'm not convinced this is sufficient. But it really would have to be tested with an actual HDMI source. A key difference between supporting a video input connector such as HDMI compared to a fixed camera or video output is that you do not control what you receive. I've been working with this for many years, and it is amazing what problems you can get due to this. So received frames can be corrupt (make sure you can handle the V4L2_BUF_FLAG_ERROR flag as result of a VIDIOC_DQBUF!) or the DMA engine can get into a bad state, requiring you to stop streaming and reconfigure (EIO returned by VIDIOC_(D)QBUF). A good driver to test such errors with is vivid, which can emulate webcams, SDTV or an HDMI receiver and has error injection to test these scenarios. See here for extensive documentation of this driver: https://hverkuil.home.xs4all.nl/spec/v4l-drivers/vivid.html I would recommend that you use this driver as a test HW driver since it can be configured in many different ways and is representative of actual HW. Exception is for HDMI where connect/disconnect is not properly emulated yet. If you need that, let me know. Regards, Hans >> We have ideas on how to address that, but as I said, nothing is implemented >> yet. Basically we need to allow for partial bring-up and inform userspace >> what is and what is not running. >> >> But this is likely something you also need to consider in this API, given >> the use-case you are looking at. >> >> Regards, >> >> Hans > Thank you for your valuable comments, > Oleksandr > > [1] > https://elixir.bootlin.com/linux/v4.19-rc3/source/drivers/gpu/drm/xen/xen_drm_front.c#L721 > [2] > https://elixir.bootlin.com/linux/v4.19-rc3/source/drivers/gpu/drm/xen/xen_drm_front.c#L582 > From mboxrd@z Thu Jan 1 00:00:00 1970 From: Hans Verkuil Subject: Re: [PATCH 1/1] cameraif: add ABI for para-virtual camera Date: Mon, 10 Sep 2018 10:14:28 +0200 Message-ID: References: <20180731093142.3828-1-andr2000@gmail.com> <20180731093142.3828-2-andr2000@gmail.com> <99cd131d-85ae-bbfb-61ef-fdc0401727f6@suse.com> <5505e5af-5b64-b317-a0d8-09c11317926f@gmail.com> <345d7ec3-3ca3-e8fe-28a0-ba299196b5e4@gmail.com> <53189190-ffe0-9795-b01c-01de8db83acb@gmail.com> <641cd785-c5e7-7552-dc4b-35249f1f1985@xs4all.nl> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from all-amaz-eas1.inumbo.com ([34.197.232.57]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1fzHL8-0007ws-Al for xen-devel@lists.xenproject.org; Mon, 10 Sep 2018 08:14:34 +0000 In-Reply-To: Content-Language: en-US List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" To: Oleksandr Andrushchenko , Juergen Gross , xen-devel@lists.xenproject.org, konrad.wilk@oracle.com, boris.ostrovsky@oracle.com, mchehab@kernel.org, linux-media@vger.kernel.org, sakari.ailus@linux.intel.com, koji.matsuoka.xm@renesas.com Cc: Artem Mygaiev , Oleksandr Andrushchenko List-Id: xen-devel@lists.xenproject.org T24gMDkvMTAvMjAxOCAwNzo1OSBBTSwgT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gd3JvdGU6Cj4g SGksIEhhbnMhCj4gCj4gT24gMDkvMDkvMjAxOCAwMTo0MiBQTSwgSGFucyBWZXJrdWlsIHdyb3Rl Ogo+PiBPbiAwOS8wNC8yMDE4IDA4OjU2IEFNLCBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyB3cm90 ZToKPj4+IE9uIDA5LzAzLzIwMTggMDY6MjUgUE0sIEhhbnMgVmVya3VpbCB3cm90ZToKPj4+PiBI aSBPbGVrc2FuZHIsCj4+Pj4KPj4+PiBPbiAwOS8wMy8yMDE4IDEyOjE2IFBNLCBPbGVrc2FuZHIg QW5kcnVzaGNoZW5rbyB3cm90ZToKPj4+Pj4gT24gMDgvMjEvMjAxOCAwODo1NCBBTSwgT2xla3Nh bmRyIEFuZHJ1c2hjaGVua28gd3JvdGU6Cj4+Pj4+PiBPbiAwOC8xNC8yMDE4IDExOjMwIEFNLCBK dWVyZ2VuIEdyb3NzIHdyb3RlOgo+Pj4+Pj4+IE9uIDMxLzA3LzE4IDExOjMxLCBPbGVrc2FuZHIg QW5kcnVzaGNoZW5rbyB3cm90ZToKPj4+Pj4+Pj4gRnJvbTogT2xla3NhbmRyIEFuZHJ1c2hjaGVu a28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgo+Pj4+Pj4+Pgo+Pj4+Pj4+PiBU aGlzIGlzIHRoZSBBQkkgZm9yIHRoZSB0d28gaGFsdmVzIG9mIGEgcGFyYS12aXJ0dWFsaXplZAo+ Pj4+Pj4+PiBjYW1lcmEgZHJpdmVyIHdoaWNoIGV4dGVuZHMgWGVuJ3MgcmVhY2ggbXVsdGltZWRp YSBjYXBhYmlsaXRpZXMgZXZlbgo+Pj4+Pj4+PiBmYXJ0aGVyIGVuYWJsaW5nIGl0IGZvciB2aWRl byBjb25mZXJlbmNpbmcsIEluLVZlaGljbGUgSW5mb3RhaW5tZW50LAo+Pj4+Pj4+PiBoaWdoIGRl ZmluaXRpb24gbWFwcyBldGMuCj4+Pj4+Pj4+Cj4+Pj4+Pj4+IFRoZSBpbml0aWFsIGdvYWwgaXMg dG8gc3VwcG9ydCBtb3N0IG5lZWRlZCBmdW5jdGlvbmFsaXR5IHdpdGggdGhlCj4+Pj4+Pj4+IGZp bmFsIGlkZWEgdG8gbWFrZSBpdCBwb3NzaWJsZSB0byBleHRlbmQgdGhlIHByb3RvY29sIGlmIG5l ZWQgYmU6Cj4+Pj4+Pj4+Cj4+Pj4+Pj4+IDEuIFByb3ZpZGUgbWVhbnMgZm9yIGJhc2UgdmlydHVh bCBkZXZpY2UgY29uZmlndXJhdGlvbjoKPj4+Pj4+Pj4gICAgIC0gcGl4ZWwgZm9ybWF0cwo+Pj4+ Pj4+PiAgICAgLSByZXNvbHV0aW9ucwo+Pj4+Pj4+PiAgICAgLSBmcmFtZSByYXRlcwo+Pj4+Pj4+ PiAyLiBTdXBwb3J0IGJhc2ljIGNhbWVyYSBjb250cm9sczoKPj4+Pj4+Pj4gICAgIC0gY29udHJh c3QKPj4+Pj4+Pj4gICAgIC0gYnJpZ2h0bmVzcwo+Pj4+Pj4+PiAgICAgLSBodWUKPj4+Pj4+Pj4g ICAgIC0gc2F0dXJhdGlvbgo+Pj4+Pj4+PiAzLiBTdXBwb3J0IHN0cmVhbWluZyBjb250cm9sCj4+ Pj4+Pj4+IDQuIFN1cHBvcnQgemVyby1jb3B5aW5nIHVzZS1jYXNlcwo+Pj4+Pj4+Pgo+Pj4+Pj4+ PiBTaWduZWQtb2ZmLWJ5OiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbwo+Pj4+Pj4+PiA8b2xla3Nh bmRyX2FuZHJ1c2hjaGVua29AZXBhbS5jb20+Cj4+Pj4+Pj4gU29tZSBzdHlsZSBpc3N1ZXMgYmVs b3cuLi4KPj4+Pj4+IFdpbGwgZml4IGFsbCB0aGUgYmVsb3csIHRoYW5rIHlvdSEKPj4+Pj4+Cj4+ Pj4+PiBJIHdvdWxkIGxpa2UgdG8gZHJhdyBzb21lIGF0dGVudGlvbiBvZiB0aGUgTGludXgvVjRM IGNvbW11bml0eSB0byB0aGlzCj4+Pj4+PiBwcm90b2NvbCBhcyB0aGUgcGxhbiBpcyB0aGF0IG9u Y2UgaXQgaXMgYWNjZXB0ZWQgZm9yIFhlbiB3ZSBwbGFuIHRvCj4+Pj4+PiB1cHN0cmVhbSBhIExp bnV4IGNhbWVyYSBmcm9udC1lbmQga2VybmVsIGRyaXZlciB3aGljaCB3aWxsIGJlIGJhc2VkCj4+ Pj4+PiBvbiB0aGlzIHdvcmsgYW5kIHdpbGwgYmUgYSBWNEwyIGRldmljZSBkcml2ZXIgKHRoaXMg aXMgd2h5IEkgaGF2ZSBzZW50Cj4+Pj4+PiB0aGlzIHBhdGNoIG5vdCBvbmx5IHRvIFhlbiwgYnV0 IHRvIHRoZSBjb3JyZXNwb25kaW5nIExpbnV4IG1haWxpbmcgbGlzdAo+Pj4+Pj4gYXMgd2VsbCkK Pj4+Pj4gcGluZwo+Pj4+IFNvcnJ5LCB0aGlzIGdvdCBidXJpZWQgaW4gbXkgbWFpbGJveCwgSSBv bmx5IGNhbWUgYWNyb3NzIGl0IHRvZGF5LiBJJ2xsIHRyeQo+Pj4+IHRvIHJldmlldyB0aGlzIHRo aXMgd2VlaywgaWYgbm90LCBqdXN0IHBpbmcgbWUgYWdhaW4uCj4+PiBUaGFuayB5b3UgZm9yIHlv dXIgdGltZQo+Pj4+IEkgaGFkIG9uZSBoaWdoLWxldmVsIHF1ZXN0aW9uLCB0aG91Z2g6Cj4+Pj4K Pj4+PiBXaGF0IHR5cGVzIG9mIGhhcmR3YXJlIGRvIHlvdSBpbnRlbmQgdG8gdGFyZ2V0PyBUaGlz IGluaXRpYWwgdmVyc2lvbiB0YXJnZXRzCj4+Pj4gKHZlcnkpIHNpbXBsZSB3ZWJjYW1zLCBidXQg d2hhdCBhYm91dCBIRE1JIG9yIFNEVFYgcmVjZWl2ZXJzPyBPciBoYXJkd2FyZQo+Pj4+IGNvZGVj cz8gT3IgY29tcGxleCBlbWJlZGRlZCB2aWRlbyBwaXBlbGluZXM/Cj4+Pj4KPj4+PiBJbiBvdGhl ciB3b3Jkcywgd2hlcmUgYXJlIHlvdSBwbGFubmluZyB0byBkcmF3IHRoZSBsaW5lPwo+Pj4+Cj4+ Pj4gRXZlbiB3aXRoIGp1c3Qgc2ltcGxlIGNhbWVyYXMgdGhlcmUgaXMgYSBkaWZmZXJlbmNlIGJl dHdlZW4gcmVndWxhciBVVkMKPj4+PiB3ZWJjYW1zIGFuZCBjYW1lcmFzIHVzZWQgd2l0aCBlbWJl ZGRlZCBzeXN0ZW1zOiBmb3IgdGhlIGxhdHRlciB5b3Ugb2Z0ZW4KPj4+PiBuZWVkIHRvIHByb3Zp ZGUgbW9yZSBjb250cm9sIHcuci50LiB3aGl0ZS1iYWxhbmNpbmcgZXRjLiwgdGhpbmdzIHRoYXQg YQo+Pj4+IFVWQyB3ZWJjYW0gd2lsbCBnZW5lcmFsbHkgZG8gZm9yIHlvdSBpbiB0aGUgd2ViY2Ft J3MgZmlybXdhcmUuCj4+PiBUaGUgdXNlLWNhc2VzIHdlIHdhbnQgdG8gaW1wbGVtZW50IGFyZSBt b3N0bHkgaW4gYXV0b21vdGl2ZS9lbWJlZGRlZCBkb21haW4sCj4+PiBzbyB0aGVyZSBhcmUgbWFu eSBwZXJmb3JtYW5jZSByZXN0cmljdGlvbnMgYXBwbHkuCj4+PiBXZSBhcmUgbm90IHRhcmdldGlu ZyB2aXJ0dWFsaXppbmcgdmVyeSBjb21wbGV4IGhhcmR3YXJlIGFuZCBoYXZlIG5vCj4+PiBpbnRl bnRpb24KPj4+IHRvIG1ha2UgYSAxOjEgbWFwcGluZyBvZiB0aGUgcmVhbCBoYXJkd2FyZTogZm9y IHRoYXQgb25lIGNhbiBwYXNzLXRocm91Z2gKPj4+IGEgcmVhbCBIVyBkZXZpY2UgdG8gYSB2aXJ0 dWFsIG1hY2hpbmUgKFZNKS4gVGhlIGdvYWwgaXMgdG8gc2hhcmUgYSBzaW5nbGUKPj4+IGNhbWVy YSBkZXZpY2UgdG8gbXVsdGlwbGUgdmlydHVhbCBtYWNoaW5lcywgbm8gY29kZWNzLCByZWNlaXZl cnMgZXRjLgo+Pj4KPj4+IENvbnRyb2xsaW5nIHRoZSBzYW1lIEhXIGRldmljZSBmcm9tIGRpZmZl cmVudCBWTXMgZG9lc24ndCBsb29rIGZlYXNpYmxlOgo+Pj4gd2hhdCBpZiB0aGUgc2FtZSBjb250 cm9sIGlzIHNldCB0byBkaWZmZXJlbnQgdmFsdWVzIGZyb20gZGlmZmVyZW50IFZNcz8KPj4gWW91 IGNhbiBkbyB0aGlzLCBhY3R1YWxseTogaW4gVjRMMiB5b3UgY2FuIGdldCBhbiBldmVudCB3aGVu IGFub3RoZXIgcHJvY2Vzcwo+PiBjaGFuZ2VzIGEgY29udHJvbCwgYW5kIHVwZGF0ZSB5b3VyIG93 biBHVUkvaW50ZXJuYWwgc3RhdGUgYWNjb3JkaW5nbHkuCj4+Cj4+IFNvIGluIHRoaXMgY2FzZSBp ZiBvbmUgVk0gY2hhbmdlcyBhIGNvbnRyb2wsIGFuIGV2ZW50IGlzIHNlbnQgdG8gYWxsIG90aGVy cwo+PiB0aGF0IHRoZSBjb250cm9sIGhhcyBjaGFuZ2VkIHZhbHVlLgo+IFdlbGwsIHRlY2huaWNh bGx5IHRoaXMgY2FuIGJlIGRvbmUgYnkgaW50cm9kdWNpbmcgb25lIG1vcmUKPiBldmVudCBmb3Ig c3VjaCBhIG5vdGlmaWNhdGlvbi4gQnV0LCBmcm9tIHN5c3RlbSBwYXJ0aXRpb25pbmcKPiBQT1Ys IEkgYW0gc3RpbGwgbm90IGNvbnZpbmNlZCB0aGlzIHNob3VsZCBiZSBkb25lOiBJIHdvdWxkIHBy ZWZlcgo+IHRoYXQgYSBzaW5nbGUgVk0gb3ducyBzdWNoIGEgY29udHJvbCBhbmQgZXZlbiB3aGlj aCBjb250cm9sIGFuZCB3aGljaAo+IFZNIGlzIGRlY2lkZWQgd2hpbGUgY29uZmlndXJpbmcgdGhl IHdob2xlIHN5c3RlbS4KPiBTbywgSSB3b3VsZCBsaWtlIHRvIGtlZXAgaXQgYXMgaXMuCgpXZWxs LCBJIGFtIG5vdCBjb252aW5jZWQgeW91IGNhbiBhdm9pZCB0aGlzOiBzb21lIGNvbnRyb2xzIGFy ZSBzZXQgYnkgZHJpdmVycwp3aGVuIHNvbWV0aGluZyBoYXBwZW5zIGFuZCBzbyBhcHBsaWNhdGlv bnMgd2lsbCBzdWJzY3JpYmUgdG8gdGhlIGNvbnRyb2wgYW5kCndhaXQgZm9yIGNoYW5nZXMgaW4g dGhlaXIgdmFsdWVzLiBXaGlsZSB0aGlzIGlzIGZvciBtb3JlIGFkdmFuY2VkIHVzZS1jYXNlcwoo Y2VydGFpbmx5IG1vcmUgdGhhbiB3aGF0IHlvdSBwcm9wb3NlIHRvZGF5KSwgSSB3b3VsZCBzdWdn ZXN0IHRoYXQgaXQgaXMgd2lzZQp0byBhdCBsZWFzdCB0aGluayBvbiBob3cgdGhpcyBjYW4gYmUg YWRkZWQgaW4gdGhlIGZ1dHVyZS4KCkNvbnRyb2xzIGFuZCBjb250cm9sIGV2ZW50cyBhcmUgYSBr ZXkgcGFydCBvZiBWNEwyLgoKPj4KPj4+IE9mIGNvdXJzZSwgdGhpcyBjYW4gYmUgYWNoaWV2ZWQg aWYgdGhlIGNvcnJlc3BvbmRpbmcgYmFja2VuZCBjYW4KPj4+IHBvc3QtcHJvY2Vzcwo+Pj4gb3Jp Z2luYWwgY2FtZXJhIGltYWdlIHdpdGggR1BVLCBmb3IgZXhhbXBsZSwgdGh1cyBhcHBseWluZyBk aWZmZXJlbnQgZmlsdGVycwo+Pj4gZm9yIGRpZmZlcmVudCBWTXMgZWZmZWN0aXZlbHkgZW11bGF0 aW5nIGNhbWVyYSBjb250cm9scy4KPj4+IEJ1dCB0aGlzIHJlcXVpcmVzIGFkZGl0aW9uYWwgQ1BV L0dQVSBwb3dlciB3aGljaCB3ZSB0cnkgdG8gYXZvaWQuCj4+Pgo+Pj4gU3lzdGVtIHBhcnRpdGlv bmluZyAoY2FtZXJhIGFuZCBjb250cm9scyBhc3NpZ25tZW50KSBpcyBkb25lIGF0Cj4+PiBjb25m aWd1cmF0aW9uCj4+PiB0aW1lIChyZW1lbWJlciB3ZSBhcmUgaW4gYXV0b21vdGl2ZS9lbWJlZGRl ZCB3b3JsZCwgc28gbW9zdCBvZiB0aGUgdGltZQo+Pj4gdGhlIHNldAo+Pj4gb2YgVk1zIHJlcXVp cmluZyBjYW1lcmFzIGlzIGtub3duIGF0IHRoaXMgc3RhZ2UgYW5kIHRoZSBjb25maWd1cmF0aW9u Cj4+PiByZW1haW5zCj4+PiBzdGF0aWMgYXQgcnVuLXRpbWUpLiBTbywgd2hlbiBwYXJhLXZpcnR1 YWxpemVkIChQVikgYXBwcm9hY2ggaXMgdXNlZCB0aGVuIHdlCj4+PiBvbmx5IGltcGxlbWVudCB2 ZXJ5IGJhc2ljIGNvbnRyb2xzICh0aG9zZSBmb3VuZCBpbiB0aGUgcHJvdG9jb2wpLCBzbyBvbmUg Y2FuCj4+PiBhc3NpZ24gc2V0IG9mIGNvbnRyb2xzIChhbGwgb3Igc29tZSkgdG8gb25lIG9mIHRo ZSBWTXMgKG1haW4gb3IgbWlzc2lvbgo+Pj4gY3JpdGljYWwKPj4+IFZNIG9yIHdoYXRldmVyKSBh bGxvd2luZyB0aGF0IFZNIHRvIGFkanVzdHMgdGhvc2UgZm9yIGFsbCBWTXMgYXQgb25jZS4KPj4+ IEZvciBvdGhlcgo+Pj4gVk1zIHRoaW5rIG9mIGl0IGFzIGZpcm13YXJlIGltcGxlbWVudGVkIGFk anVzdG1lbnQuIEFuZCB0aGUgYmFja2VuZCBzdGlsbAo+Pj4gY29udHJvbHMgdGhlIHJlc3Qgb2Yg dGhlIGNvbnRyb2xzIG9mIHRoZSByZWFsIEhXIGNhbWVyYSB5b3UgbWVudGlvbi4KPj4+Cj4+PiBK dXN0IGFuIGV4YW1wbGUgb2YgYXV0b21vdGl2ZSB1c2UtY2FzZSAod2UgY2FuIGltYWdpbmUgbWFu eSBtb3JlKToKPj4+IDEuIERyaXZlciBEb21haW4gLSBvd25zIHJlYWwgY2FtZXJhIEhXIGFuZCBy dW5zIHRoZSBjYW1lcmEgYmFja2VuZC4KPj4+ICAgICAgVXNlcyBjYW1lcmEgb3V0cHV0IGZvciBt aXNzaW9uIGNyaXRpY2FsIHRhc2tzLCBlLmcuIHBhcmtpbmcgYXNzaXN0YW5jZS4KPj4+IDIuIElu LVZlaGljbGUgSW5mb3RhaW5tZW50IGRvbWFpbiAtIHVzZXMgUFYgY2FtZXJhIGZvciBpbmZvdGFp bm1lbnQKPj4+IHB1cnBvc2VzLAo+Pj4gICAgICBlLmcuIHRha2luZyBwaWN0dXJlcyB3aGlsZSBp biBtb3Rpb24uCj4+PiAzLiBOYXZpZ2F0aW9uIGRvbWFpbiAtIHVzZXMgUFYgY2FtZXJhIGZvciBo aWdoIGRlZmluaXRpb24gbWFwcwo+Pj4KPj4+IEhvcGUsIHRoaXMgaGVscHMgdW5kZXJzdGFuZGlu ZyB0aGUgcG9zc2libGUgdXNlcyBvZiB0aGUgcHJvcG9zZWQKPj4+IHByb3RvY29sLCBpdHMKPj4+ IGludGVudGlvbiBhbmQgcmVzdHJpY3Rpb25zLgo+PiBSaWdodCwgc28gaW4gdGhpcyBzY2VuYXJp byB5b3UgcHJvYmFibHkgZG8gbm90IHdhbnQgaG90cGx1Z2dhYmxlCj4+IHNvdXJjZXMgaW4gdGhl IERyaXZlciBEb21haW4uIFNvIHN1cHBvcnQgZm9yIGZpeGVkIGNhbWVyYSdzIG9ubHkuCj4gV2Vs bCwgc29tZSBzb3J0IG9mIGhvdHBsdWcgY2FuIGFscmVhZHkgYmUgaW1wbGVtZW50ZWQsIHBsZWFz ZQo+IHNlZSBbMV0sIFsyXSBhcyBpdCBpcyBkb25lIGZvciB2aXJ0dWFsIGRpc3BsYXk6IHRoaXMg aXMKPiBhY2hpZXZlZCBhcyBhIHJlc3BvbnNlIHRvIHRoZSBiYWNrZW5kJ3Mgc3RhdGUgY2hhbmdl LAo+IGUuZy4gd2hlbmV2ZXIgYmFja2VuZCBkZWNpZGVzIHRvIHVucGx1ZyB0aGUgdmlydHVhbCBk ZXZpY2UKPiBpdCBjaGFuZ2VzIGl0cyBzdGF0ZSBhY2NvcmRpbmdseS4KPj4KPj4gSWYgdGhpcyBp cyBpbmRlZWQgdGhlIGNhc2UsIHRoZW4gdGhpcyBzaG91bGQgYmUgbWFkZSB2ZXJ5IGNsZWFyIGlu Cj4+IHRoZSBBUEkgc3BlY2lmaWNhdGlvbi4KPiBBcyBJIGRlc2NyaWJlZCBhYm92ZSB0aGlzIGlz IGFscmVhZHkgYXNzdW1lZCBieSB0aGUgc3RhdGUKPiBtYWNoaW5lIG9mIGEgeGVuYnVzX2RyaXZl cgo+PiBPbmUgYWRkaXRpb25hbCB0aGluZyB0byBjb25zaWRlcjogY2FtZXJhcyBjYW4gYnJlYWsu IFNvIHdoYXQgc2hvdWxkIGJlCj4+IGRvbmUgaWYgdGhhdCBoYXBwZW5zPyBXZSBhcyBtZWRpYSBk ZXZlbG9wZXJzIGhhdmUgaWRlYXMgYWJvdXQgdGhhdCwgYnV0Cj4+IG5vdGhpbmcgaGFzIGJlZW4g aW1wbGVtZW50ZWQgKHlldCkuCj4+Cj4+IElmIHRoZSBIVyBpcyBzaW1wbGUgKG9uZSBjYW1lcmEg aXMgZHJpdmVuIGJ5IGEgc2luZ2xlIGRyaXZlciBpbnN0YW5jZSksCj4+IHRoZW4gaWYgaXQgYnJl YWtzLCB0aGVyZSBzaW1wbHkgd29uJ3QgYmUgYSB2aWRlbyBkZXZpY2UuIEJ1dCBpZiB5b3UgaGF2 ZQo+PiBtdWx0aXBsZSBjYW1lcmFzIGFsbCBjb250cm9sbGVkIHRocm91Z2ggdGhlIHNhbWUgZHJp dmVyIGluc3RhbmNlLCB0aGVuIHRvZGF5Cj4+IGlmIGEgc2luZ2xlIGNhbWVyYSBicmVha3MsIGFs bCBhcmUgZ29uZS4KPiBQbGVhc2Ugc2VlIGFib3ZlCgpJJ20gbm90IGNvbnZpbmNlZCB0aGlzIGlz IHN1ZmZpY2llbnQuIEJ1dCBpdCByZWFsbHkgd291bGQgaGF2ZSB0byBiZSB0ZXN0ZWQKd2l0aCBh biBhY3R1YWwgSERNSSBzb3VyY2UuCgpBIGtleSBkaWZmZXJlbmNlIGJldHdlZW4gc3VwcG9ydGlu ZyBhIHZpZGVvIGlucHV0IGNvbm5lY3RvciBzdWNoIGFzIEhETUkKY29tcGFyZWQgdG8gYSBmaXhl ZCBjYW1lcmEgb3IgdmlkZW8gb3V0cHV0IGlzIHRoYXQgeW91IGRvIG5vdCBjb250cm9sIHdoYXQK eW91IHJlY2VpdmUuIEkndmUgYmVlbiB3b3JraW5nIHdpdGggdGhpcyBmb3IgbWFueSB5ZWFycywg YW5kIGl0IGlzIGFtYXppbmcKd2hhdCBwcm9ibGVtcyB5b3UgY2FuIGdldCBkdWUgdG8gdGhpcy4K ClNvIHJlY2VpdmVkIGZyYW1lcyBjYW4gYmUgY29ycnVwdCAobWFrZSBzdXJlIHlvdSBjYW4gaGFu ZGxlIHRoZQpWNEwyX0JVRl9GTEFHX0VSUk9SIGZsYWcgYXMgcmVzdWx0IG9mIGEgVklESU9DX0RR QlVGISkgb3IgdGhlIERNQSBlbmdpbmUgY2FuIGdldAppbnRvIGEgYmFkIHN0YXRlLCByZXF1aXJp bmcgeW91IHRvIHN0b3Agc3RyZWFtaW5nIGFuZCByZWNvbmZpZ3VyZSAoRUlPIHJldHVybmVkCmJ5 IFZJRElPQ18oRClRQlVGKS4KCkEgZ29vZCBkcml2ZXIgdG8gdGVzdCBzdWNoIGVycm9ycyB3aXRo IGlzIHZpdmlkLCB3aGljaCBjYW4gZW11bGF0ZSB3ZWJjYW1zLCBTRFRWIG9yCmFuIEhETUkgcmVj ZWl2ZXIgYW5kIGhhcyBlcnJvciBpbmplY3Rpb24gdG8gdGVzdCB0aGVzZSBzY2VuYXJpb3MuIFNl ZSBoZXJlIGZvcgpleHRlbnNpdmUgZG9jdW1lbnRhdGlvbiBvZiB0aGlzIGRyaXZlcjoKCmh0dHBz Oi8vaHZlcmt1aWwuaG9tZS54czRhbGwubmwvc3BlYy92NGwtZHJpdmVycy92aXZpZC5odG1sCgpJ IHdvdWxkIHJlY29tbWVuZCB0aGF0IHlvdSB1c2UgdGhpcyBkcml2ZXIgYXMgYSB0ZXN0IEhXIGRy aXZlciBzaW5jZSBpdCBjYW4KYmUgY29uZmlndXJlZCBpbiBtYW55IGRpZmZlcmVudCB3YXlzIGFu ZCBpcyByZXByZXNlbnRhdGl2ZSBvZiBhY3R1YWwgSFcuCgpFeGNlcHRpb24gaXMgZm9yIEhETUkg d2hlcmUgY29ubmVjdC9kaXNjb25uZWN0IGlzIG5vdCBwcm9wZXJseSBlbXVsYXRlZCB5ZXQuCklm IHlvdSBuZWVkIHRoYXQsIGxldCBtZSBrbm93LgoKUmVnYXJkcywKCglIYW5zCgo+PiBXZSBoYXZl IGlkZWFzIG9uIGhvdyB0byBhZGRyZXNzIHRoYXQsIGJ1dCBhcyBJIHNhaWQsIG5vdGhpbmcgaXMg aW1wbGVtZW50ZWQKPj4geWV0LiBCYXNpY2FsbHkgd2UgbmVlZCB0byBhbGxvdyBmb3IgcGFydGlh bCBicmluZy11cCBhbmQgaW5mb3JtIHVzZXJzcGFjZQo+PiB3aGF0IGlzIGFuZCB3aGF0IGlzIG5v dCBydW5uaW5nLgo+Pgo+PiBCdXQgdGhpcyBpcyBsaWtlbHkgc29tZXRoaW5nIHlvdSBhbHNvIG5l ZWQgdG8gY29uc2lkZXIgaW4gdGhpcyBBUEksIGdpdmVuCj4+IHRoZSB1c2UtY2FzZSB5b3UgYXJl IGxvb2tpbmcgYXQuCj4+Cj4+IFJlZ2FyZHMsCj4+Cj4+IAlIYW5zCj4gVGhhbmsgeW91IGZvciB5 b3VyIHZhbHVhYmxlIGNvbW1lbnRzLAo+IE9sZWtzYW5kcgo+IAo+IFsxXSAKPiBodHRwczovL2Vs aXhpci5ib290bGluLmNvbS9saW51eC92NC4xOS1yYzMvc291cmNlL2RyaXZlcnMvZ3B1L2RybS94 ZW4veGVuX2RybV9mcm9udC5jI0w3MjEKPiBbMl0gCj4gaHR0cHM6Ly9lbGl4aXIuYm9vdGxpbi5j b20vbGludXgvdjQuMTktcmMzL3NvdXJjZS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJv bnQuYyNMNTgyCj4gCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18KWGVuLWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVucHJvamVjdC5v cmcKaHR0cHM6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL3hlbi1kZXZl bA==