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=-15.9 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, MENTIONS_GIT_HOSTING,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_SBL, URIBL_SBL_A,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 14FEDC433E4 for ; Fri, 21 Aug 2020 12:59:39 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id D8D402078D for ; Fri, 21 Aug 2020 12:59:38 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="X6jhyM3o" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728766AbgHUM7g (ORCPT ); Fri, 21 Aug 2020 08:59:36 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58494 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728737AbgHUM7U (ORCPT ); Fri, 21 Aug 2020 08:59:20 -0400 Received: from mail-qk1-x741.google.com (mail-qk1-x741.google.com [IPv6:2607:f8b0:4864:20::741]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 195EAC061387; Fri, 21 Aug 2020 05:59:20 -0700 (PDT) Received: by mail-qk1-x741.google.com with SMTP id 2so1223969qkf.10; Fri, 21 Aug 2020 05:59:20 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=0ekCKllPOZ8Wr18F4aZIRtwIo8BDZiwXNgOPMTdFB30=; b=X6jhyM3o6Gh7eLI4enAeof7JbtyCMdSJ+Xghy+voGJYXiRriYo/QzDUVyd6zhg8hsQ HcdpFWrsWXF47sBtSY3wXvJiBmo1TngHgVlJ4jmihua4yMRrJRMNXGq+4bY66WF10OG6 h6jaI7aQ8veiTdJPKq9+moQfgwc9Jf9+LhB6IPYfyhU94Li51XDwBHQKPxzaU5CmnfPn 2nu5lpUbb0LUJ3eD56fR1Vwnnz0ahPl1VijHY5KKk1O2GsC/n6Ghui4NY3rESanD3weu Hf3ENovl3gkm4BNiUYw/+aFo+RAny0CSIVQhtrwR+yZiy1r2E6bnVOv2vvwtY3tThSwJ FTLg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=0ekCKllPOZ8Wr18F4aZIRtwIo8BDZiwXNgOPMTdFB30=; b=hfJ3P7T3+6SY6+kf9zJcfEPkwMrV4gNaLPWTx2773wdyGHFfebEqoykNtOp2ls4E6m GFDQpAY+xv9otyCgKnn1gzz/jbuq3XjsX6T8wiGf0pmEtwWzpe1fyNbvt9Lq2n1N01o3 Us1QVldbaYbPfxzZ4nuUBTq5la7QC//npAV+sF60qsMNKI9i3KdOvs41DXcmdp76M4OQ 9DFI5TIIOvLp7mtNfqvgMr1QB0wyYFWc18JRZPvkz2YM15lMWJHKenGq/6KudLvkcJvV TOKk9HM4L7r1SghlJ14ajg+11FwoZxZxZIhMWQSnyvDhQ9z14XoqvAkwe2S+WfuC3SGZ DV7w== X-Gm-Message-State: AOAM533xyRDnQIIoxB6erdBtocYEAQulBq3rDZeH3EDYFKPOHkYTQCwj AYcjSxnJ3AibD/N83Tkv9cI= X-Google-Smtp-Source: ABdhPJxPjHdfbBlE0TxZ0BGq4c4Cz7b9lrqTgdgMCzjuaW2E+x0UE5R/F9jAzQdJeR3Ud7/qTxZdYg== X-Received: by 2002:a05:620a:2041:: with SMTP id d1mr953137qka.401.1598014758934; Fri, 21 Aug 2020 05:59:18 -0700 (PDT) Received: from localhost.localdomain ([2804:14d:72b1:8920:da15:c0bd:33c1:e2ad]) by smtp.gmail.com with ESMTPSA id w18sm2042525qtk.1.2020.08.21.05.59.15 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 21 Aug 2020 05:59:18 -0700 (PDT) From: "Daniel W. S. Almeida" X-Google-Original-From: Daniel W. S. Almeida To: mchehab+huawei@kernel.org, r.verdejo@samsung.com, nicolas@ndufresne.ca Cc: "Daniel W. S. Almeida" , linux-media@vger.kernel.org, skhan@linuxfoundation.org, linux-kernel-mentees@lists.linuxfoundation.org, linux-kernel@vger.kernel.org Subject: [v10 4/4] media: Documentation: vidtv: Add ReST documentation for vidtv Date: Fri, 21 Aug 2020 09:58:48 -0300 Message-Id: <20200821125848.1092958-5-dwlsalmeida@gmail.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20200821125848.1092958-1-dwlsalmeida@gmail.com> References: <20200821125848.1092958-1-dwlsalmeida@gmail.com> 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: "Daniel W. S. Almeida" Add documentation for the Virtual Digital TV driver (vidtv) in the Restructured Text (ReST) format. This discusses: - What is vidtv - Why vidtv is needed - How to build and run vidtv - How vidtv is structured - How to test vidtv - How to improve vidtv Signed-off-by: Daniel W. S. Almeida --- .../driver-api/media/drivers/index.rst | 1 + .../driver-api/media/drivers/vidtv.rst | 417 ++++++++++++++++++ 2 files changed, 418 insertions(+) create mode 100644 Documentation/driver-api/media/drivers/vidtv.rst diff --git a/Documentation/driver-api/media/drivers/index.rst b/Documentation/driver-api/media/drivers/index.rst index 0df85fc96605..5f340cfdb4cc 100644 --- a/Documentation/driver-api/media/drivers/index.rst +++ b/Documentation/driver-api/media/drivers/index.rst @@ -35,4 +35,5 @@ Digital TV drivers dvb-usb frontends + vidtv contributors diff --git a/Documentation/driver-api/media/drivers/vidtv.rst b/Documentation/driver-api/media/drivers/vidtv.rst new file mode 100644 index 000000000000..303227a67f60 --- /dev/null +++ b/Documentation/driver-api/media/drivers/vidtv.rst @@ -0,0 +1,417 @@ +.. SPDX-License-Identifier: GPL-2.0 + +================================ +vidtv: Virtual Digital TV driver +================================ + +Author: Daniel W. S. Almeida , June 2020. + +Background +---------- + +Vidtv is a virtual DVB driver that aims to serve as a reference for driver +writers by serving as a template. It also validates the existing media DVB +APIs, thus helping userspace application writers. + +Currently, it consists of: + +- A fake tuner driver, which will report a bad signal quality if the chosen + frequency is too far away from a table of valid frequencies for a + particular delivery system. + +- A fake demod driver, which will constantly poll the fake signal quality + returned by the tuner, simulating a device that can lose/reacquire a lock + on the signal depending on the CNR levels. + +- A fake bridge driver, which is the module responsible for modprobing the + fake tuner and demod modules and implementing the demux logic. This module + takes parameters at initialization that will dictate how the simulation + behaves. + +- Code reponsible for encoding a valid MPEG Transport Stream, which is then + passed to the bridge driver. This fake stream contains some hardcoded content. + For now, we have a single, audio-only channel containing a single MPEG + Elementary Stream, which in turn contains a SMPTE 302m encoded sine-wave. + Note that this particular encoder was chosen because it is the easiest + way to encode PCM audio data in a MPEG Transport Stream. + +Building vidtv +-------------- +vidtv is a test driver and thus is **not** enabled by default when +compiling the kernel. + +In order to enable compilation of vidtv: + +- Enable **DVB_TEST_DRIVERS**, then +- Enable **DVB_VIDTV** + +When compiled as a module, expect the following .ko files: + +- dvb_vidtv_tuner.ko + +- dvb_vidtv_demod.ko + +- dvb_vidtv_bridge.ko + +Running vidtv +------------- +When compiled as a module, run:: + + modprobe dvb_vidtv_bridge + +That's it! The bridge driver will initialize the tuner and demod drivers as +part of its own initialization. + +You can optionally define some command-line arguments to vidtv. + +Command-line arguments to vidtv +------------------------------- +Below is a list of all arguments that can be supplied to vidtv: + +drop_tslock_prob_on_low_snr + Probability of losing the TS lock if the signal quality is bad. + This probability be used by the fake demodulator driver to + eventually return a status of 0 when the signal quality is not + good. + +recover_tslock_prob_on_good_snr: + Probability recovering the TS lock when the signal improves. This + probability be used by the fake demodulator driver to eventually + return a status of 0x1f when/if the signal quality improves. + +mock_power_up_delay_msec + Simulate a power up delay. Default: 0. + +mock_tune_delay_msec + Simulate a tune delay. Default 0. + +vidtv_valid_dvb_t_freqs + Valid DVB-T frequencies to simulate. + +vidtv_valid_dvb_c_freqs + Valid DVB-C frequencies to simulate. + +vidtv_valid_dvb_s_freqs + Valid DVB-C frequencies to simulate. + +max_frequency_shift_hz, + Maximum shift in HZ allowed when tuning in a channel. + +si_period_msec + How often to send SI packets. Default: 40ms. + +pcr_period_msec + How often to send PCR packets. Default: 40ms. + +mux_rate_kbytes_sec + Attempt to maintain this bit rate by inserting TS null packets, if + necessary. Default: 4096. + +pcr_pid, + PCR PID for all channels. Default: 0x200. + +mux_buf_sz_pkts, + Size for the mux buffer in multiples of 188 bytes. + +vidtv internal structure +------------------------ +The kernel modules are split in the following way: + +vidtv_tuner.[ch] + Implements a fake tuner DVB driver. + +vidtv_demod.[ch] + Implements a fake demodulator DVB driver. + +vidtv_bridge.[ch] + Implements a bridge driver. + +The MPEG related code is split in the following way: + +vidtv_ts.[ch] + Code to work with MPEG TS packets, such as TS headers, adaptation + fields, PCR packets and NULL packets. + +vidtv_psi.[ch] + This is the PSI generator. PSI packets contain general information + about a MPEG Transport Stream. A PSI generator is needed so + userspace apps can retrieve information about the Transport Stream + and eventually tune into a (dummy) channel. + + Because the generator is implemented in a separate file, it can be + reused elsewhere in the media subsystem. + + Currently vidtv supports working with 3 PSI tables: PAT, PMT and + SDT. + + The specification for PAT and PMT can be found in *ISO 13818-1: + Systems*, while the specification for the SDT can be found in *ETSI + EN 300 468: Specification for Service Information (SI) in DVB + systems*. + + It isn't strictly necessary, but using a real TS file helps when + debugging PSI tables. Vidtv currently tries to replicate the PSI + structure found in this file: `TS1Globo.ts + `_. + + A good way to visualize the structure of streams is by using + `DVBInspector `_. + +vidtv_pes.[ch] + Implements the PES logic to convert encoder data into MPEG TS + packets. These can then be fed into a TS multiplexer and eventually + into userspace. + +vidtv_encoder.h + An interface for vidtv encoders. New encoders can be added to this + driver by implementing the calls in this file. + +vidtv_s302m.[ch] + Implements a S302M encoder to make it possible to insert PCM audio + data in the generated MPEG Transport Stream. The relevant + specification is available online as *SMPTE 302M-2007: Television - + Mapping of AES3 Data into MPEG-2 Transport Stream*. + + + The resulting MPEG Elementary Stream is conveyed in a private + stream with a S302M registration descriptor attached. + + This shall enable passing an audio signal into userspace so it can + be decoded and played by media software. The corresponding decoder + in ffmpeg is located in 'libavcodec/s302m.c' and is experimental. + +vidtv_channel.[ch] + Implements a 'channel' abstraction. + + When vidtv boots, it will create some hardcoded channels: + + #. Their services will be concatenated to populate the SDT. + + #. Their programs will be concatenated to populate the PAT + + #. For each program in the PAT, a PMT section will be created + + #. The PMT section for a channel will be assigned its streams. + + #. Every stream will have its corresponding encoder polled in a + loop to produce TS packets. + These packets may be interleaved by the muxer and then delivered + to the bridge. + +vidtv_mux.[ch] + Implements a MPEG TS mux, loosely based on the ffmpeg + implementation in "libavcodec/mpegtsenc.c" + + The muxer runs a loop which is responsible for: + + #. Keeping track of the amount of time elapsed since the last + iteration. + + #. Polling encoders in order to fetch 'elapsed_time' worth of data. + + #. Inserting PSI and/or PCR packets, if needed. + + #. Padding the resulting stream with NULL packets if + necessary in order to maintain the chosen bit rate. + + #. Delivering the resulting TS packets to the bridge + driver so it can pass them to the demux. + +Testing vidtv with v4l-utils +---------------------------- + +Using the tools in v4l-utils is a great way to test and inspect the output of +vidtv. It is hosted here: `v4l-utils Documentation +`_. + +From its webpage:: + + The v4l-utils are a series of packages for handling media devices. + + It is hosted at http://git.linuxtv.org/v4l-utils.git, and packaged + on most distributions. + + It provides a series of libraries and utilities to be used to + control several aspect of the media boards. + + +Start by installing v4l-utils and then modprobing vidtv:: + + modprobe dvb_vidtv_bridge + +If the driver is OK, it should load and its probing code will run. This will +pull in the tuner and demod drivers. + +Using dvb-fe-tool +~~~~~~~~~~~~~~~~~ + +The first step to check whether the demod loaded successfully is to run:: + + $ dvb-fe-tool + +This should return what is currently set up at the demod struct, i.e.:: + + static const struct dvb_frontend_ops vidtv_demod_ops = { + .delsys = { + SYS_DVBT, + SYS_DVBT2, + SYS_DVBC_ANNEX_A, + SYS_DVBS, + SYS_DVBS2, + }, + + .info = { + .name = "Dummy demod for DVB-T/T2/C/S/S2", + .frequency_min_hz = 51 * MHz, + .frequency_max_hz = 2150 * MHz, + .frequency_stepsize_hz = 62500, + .frequency_tolerance_hz = 29500 * kHz, + .symbol_rate_min = 1000000, + .symbol_rate_max = 45000000, + + .caps = FE_CAN_FEC_1_2 | + FE_CAN_FEC_2_3 | + FE_CAN_FEC_3_4 | + FE_CAN_FEC_4_5 | + FE_CAN_FEC_5_6 | + FE_CAN_FEC_6_7 | + FE_CAN_FEC_7_8 | + FE_CAN_FEC_8_9 | + FE_CAN_QAM_16 | + FE_CAN_QAM_64 | + FE_CAN_QAM_32 | + FE_CAN_QAM_128 | + FE_CAN_QAM_256 | + FE_CAN_QAM_AUTO | + FE_CAN_QPSK | + FE_CAN_FEC_AUTO | + FE_CAN_INVERSION_AUTO | + FE_CAN_TRANSMISSION_MODE_AUTO | + FE_CAN_GUARD_INTERVAL_AUTO | + FE_CAN_HIERARCHY_AUTO, + } + + .... + +For more information on dvb-fe-tools check its online documentation here: +`dvb-fe-tool Documentation +`_. + +Using dvb-scan +~~~~~~~~~~~~~~ + +In order to tune into a channel and read the PSI tables, we can use dvb-scan. + +For this, one should provide a configuration file known as a 'scan file', +here's an example:: + + [Channel] + FREQUENCY = 330000000 + MODULATION = QAM/AUTO + SYMBOL_RATE = 6940000 + INNER_FEC = AUTO + DELIVERY_SYSTEM = DVBC/ANNEX_A + +.. note:: + The parameters depend on the video standard you're testing. + +.. note:: + Vidtv is a fake driver and does not validate much of the information + in the scan file. Just specifying 'FREQUENCY' and 'DELIVERY_SYSTEM' + should be enough for DVB-T/DVB-T2. For DVB-S/DVB-C however, you + should also provide 'SYMBOL_RATE'. + +You can browse scan tables online here: `dvb-scan-tables +`_. + +Assuming this channel is named 'channel.conf', you can then run:: + + $ dvbv5-scan channel.conf + +For more information on dvb-scan, check its documentation online here: +`dvb-scan Documentation `_. + +Using dvb-zap +~~~~~~~~~~~~~ + +dvbv5-zap is a command line tool that can be used to record MPEG-TS to disk. The +typical use is to tune into a channel and put it into record mode. The example +below - which is taken from the documentation - illustrates that:: + + $ dvbv5-zap -c dvb_channel.conf "trilhas sonoras" -r + using demux '/dev/dvb/adapter0/demux0' + reading channels from file 'dvb_channel.conf' + service has pid type 05: 204 + tuning to 573000000 Hz + audio pid 104 + dvb_set_pesfilter 104 + Lock (0x1f) Quality= Good Signal= 100.00% C/N= -13.80dB UCB= 70 postBER= 3.14x10^-3 PER= 0 + DVR interface '/dev/dvb/adapter0/dvr0' can now be opened + +The channel can be watched by playing the contents of the DVR interface, with +some player that recognizes the MPEG-TS format, such as *mplayer* or *vlc*. + +By playing the contents of the stream one can visually inspect the workings of +vidtv, e.g.:: + + $ mplayer /dev/dvb/adapter0/dvr0 + +For more information on dvb-zap check its online documentation here: +`dvb-zap Documentation +`_. +See also: `zap `_. + + +What can still be improved in vidtv +----------------------------------- + +Add *debugfs* integration +~~~~~~~~~~~~~~~~~~~~~~~~~ + +Although frontend drivers provide DVBv5 statistics via the .read_status +call, a nice addition would be to make additional statistics available to +userspace via debugfs, which is a simple-to-use, RAM-based filesystem +specifically designed for debug purposes. + +The logic for this would be implemented on a separate file so as not to +pollute the frontend driver. These statistics are driver-specific and can +be useful during tests. + +The Siano driver is one example of a driver using +debugfs to convey driver-specific statistics to userspace and it can be +used as a reference. + +This should be further enabled and disabled via a Kconfig +option for convenience. + +Add a way to test video +~~~~~~~~~~~~~~~~~~~~~~~ + +Currently, vidtv can only encode PCM audio. It would be great to implement +a barebones version of MPEG-2 video encoding so we can also test video. The +first place to look into is *ISO 13818-2: Information technology — Generic +coding of moving pictures and associated audio information — Part 2: Video*, +which covers the encoding of compressed video in MPEG Transport Streams. + +This might optionally use the Video4Linux2 Test Pattern Generator, v4l2-tpg, +which resides at:: + + drivers/media/common/v4l2-tpg/ + + +Add white noise simulation +~~~~~~~~~~~~~~~~~~~~~~~~~~ + +The vidtv tuner already has code to identify whether the chosen frequency +is too far away from a table of valid frequencies. For now, this means that +the demodulator can eventually lose the lock on the signal, since the tuner will +report a bad signal quality. + +A nice addition is to simulate some noise when the signal quality is bad by: + +- Randomly dropping some TS packets. This will trigger a continuity error if the + continuity counter is updated but the packet is not passed on to the demux. + +- Updating the error statistics accordingly (e.g. BER, etc). + +- Simulating some noise in the encoded data. -- 2.28.0 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=-15.6 required=3.0 tests=BAYES_00, DKIM_ADSP_CUSTOM_MED,DKIM_INVALID,DKIM_SIGNED,FREEMAIL_FORGED_FROMDOMAIN, FREEMAIL_FROM,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, MENTIONS_GIT_HOSTING,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_SBL, URIBL_SBL_A,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 9F8DFC433DF for ; Fri, 21 Aug 2020 12:59:24 +0000 (UTC) Received: from fraxinus.osuosl.org (smtp4.osuosl.org [140.211.166.137]) (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 713C22078D for ; Fri, 21 Aug 2020 12:59:24 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="X6jhyM3o" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 713C22078D Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=linux-kernel-mentees-bounces@lists.linuxfoundation.org Received: from localhost (localhost [127.0.0.1]) by fraxinus.osuosl.org (Postfix) with ESMTP id 55F9B86C06; Fri, 21 Aug 2020 12:59:24 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from fraxinus.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id Z5GEHhxHi38T; Fri, 21 Aug 2020 12:59:22 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by fraxinus.osuosl.org (Postfix) with ESMTP id 6123285631; Fri, 21 Aug 2020 12:59:22 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 50B93C07FF; Fri, 21 Aug 2020 12:59:22 +0000 (UTC) Received: from whitealder.osuosl.org (smtp1.osuosl.org [140.211.166.138]) by lists.linuxfoundation.org (Postfix) with ESMTP id EFC69C0051 for ; Fri, 21 Aug 2020 12:59:21 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by whitealder.osuosl.org (Postfix) with ESMTP id DF56788418 for ; Fri, 21 Aug 2020 12:59:21 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from whitealder.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id Cy5q7mz4oytQ for ; Fri, 21 Aug 2020 12:59:20 +0000 (UTC) X-Greylist: from auto-whitelisted by SQLgrey-1.7.6 Received: from mail-qk1-f193.google.com (mail-qk1-f193.google.com [209.85.222.193]) by whitealder.osuosl.org (Postfix) with ESMTPS id 57B198840E for ; Fri, 21 Aug 2020 12:59:20 +0000 (UTC) Received: by mail-qk1-f193.google.com with SMTP id m7so1214596qki.12 for ; Fri, 21 Aug 2020 05:59:20 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=0ekCKllPOZ8Wr18F4aZIRtwIo8BDZiwXNgOPMTdFB30=; b=X6jhyM3o6Gh7eLI4enAeof7JbtyCMdSJ+Xghy+voGJYXiRriYo/QzDUVyd6zhg8hsQ HcdpFWrsWXF47sBtSY3wXvJiBmo1TngHgVlJ4jmihua4yMRrJRMNXGq+4bY66WF10OG6 h6jaI7aQ8veiTdJPKq9+moQfgwc9Jf9+LhB6IPYfyhU94Li51XDwBHQKPxzaU5CmnfPn 2nu5lpUbb0LUJ3eD56fR1Vwnnz0ahPl1VijHY5KKk1O2GsC/n6Ghui4NY3rESanD3weu Hf3ENovl3gkm4BNiUYw/+aFo+RAny0CSIVQhtrwR+yZiy1r2E6bnVOv2vvwtY3tThSwJ FTLg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=0ekCKllPOZ8Wr18F4aZIRtwIo8BDZiwXNgOPMTdFB30=; b=oHaMmoZgPGNRDFThMFd4Q96Vuj8hfb9ZZN01Z3ke2B/AgPF7QcyRkrRqhrXQ+3GI0E XI2G9lGYWQagfEgey9lx3zHBs0HbOBTzx2JINxLFpsdbsF7CTlnJyupgcLefLEgIKh08 XvoUMn0kJxHwxbz8nA12QAd+AUAwSfu0u/26EhZCKuVQyZjE2d0cPMTHWyAtLEiWzqA9 U/MuLC4F3bg3SXfcecriasVABFcu1wAaEifeJGFZ+Ix1zq7CnHfmJdpFsYZDeXBY7BpR mNOh7lOXx4+QvFv2fQnyNFYbBO6CCCD3knCQrR/EwQNXZFuaP/U4oK88SPJ4Na3IMA+z v4tg== X-Gm-Message-State: AOAM531ci2+hik63izoLkgT99XKcWz2hNLhHjE1xhEVqHyqbDWWFUZ92 kMCxrDEzsplR7yKPBnExWg0= X-Google-Smtp-Source: ABdhPJxPjHdfbBlE0TxZ0BGq4c4Cz7b9lrqTgdgMCzjuaW2E+x0UE5R/F9jAzQdJeR3Ud7/qTxZdYg== X-Received: by 2002:a05:620a:2041:: with SMTP id d1mr953137qka.401.1598014758934; Fri, 21 Aug 2020 05:59:18 -0700 (PDT) Received: from localhost.localdomain ([2804:14d:72b1:8920:da15:c0bd:33c1:e2ad]) by smtp.gmail.com with ESMTPSA id w18sm2042525qtk.1.2020.08.21.05.59.15 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 21 Aug 2020 05:59:18 -0700 (PDT) From: "Daniel W. S. Almeida" X-Google-Original-From: Daniel W. S. Almeida To: mchehab+huawei@kernel.org, r.verdejo@samsung.com, nicolas@ndufresne.ca Date: Fri, 21 Aug 2020 09:58:48 -0300 Message-Id: <20200821125848.1092958-5-dwlsalmeida@gmail.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20200821125848.1092958-1-dwlsalmeida@gmail.com> References: <20200821125848.1092958-1-dwlsalmeida@gmail.com> MIME-Version: 1.0 Cc: linux-kernel@vger.kernel.org, linux-kernel-mentees@lists.linuxfoundation.org, "Daniel W. S. Almeida" , linux-media@vger.kernel.org Subject: [Linux-kernel-mentees] [v10 4/4] media: Documentation: vidtv: Add ReST documentation for vidtv X-BeenThere: linux-kernel-mentees@lists.linuxfoundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: linux-kernel-mentees-bounces@lists.linuxfoundation.org Sender: "Linux-kernel-mentees" RnJvbTogIkRhbmllbCBXLiBTLiBBbG1laWRhIiA8ZHdsc2FsbWVpZGFAZ21haWwuY29tPgoKQWRk IGRvY3VtZW50YXRpb24gZm9yIHRoZSBWaXJ0dWFsIERpZ2l0YWwgVFYgZHJpdmVyICh2aWR0dikg aW4gdGhlClJlc3RydWN0dXJlZCBUZXh0IChSZVNUKSBmb3JtYXQuCgpUaGlzIGRpc2N1c3NlczoK LSBXaGF0IGlzIHZpZHR2Ci0gV2h5IHZpZHR2IGlzIG5lZWRlZAotIEhvdyB0byBidWlsZCBhbmQg cnVuIHZpZHR2Ci0gSG93IHZpZHR2IGlzIHN0cnVjdHVyZWQKLSBIb3cgdG8gdGVzdCB2aWR0dgot IEhvdyB0byBpbXByb3ZlIHZpZHR2CgpTaWduZWQtb2ZmLWJ5OiBEYW5pZWwgVy4gUy4gQWxtZWlk YSA8ZHdsc2FsbWVpZGFAZ21haWwuY29tPgotLS0KIC4uLi9kcml2ZXItYXBpL21lZGlhL2RyaXZl cnMvaW5kZXgucnN0ICAgICAgICB8ICAgMSArCiAuLi4vZHJpdmVyLWFwaS9tZWRpYS9kcml2ZXJz L3ZpZHR2LnJzdCAgICAgICAgfCA0MTcgKysrKysrKysrKysrKysrKysrCiAyIGZpbGVzIGNoYW5n ZWQsIDQxOCBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgRG9jdW1lbnRhdGlvbi9k cml2ZXItYXBpL21lZGlhL2RyaXZlcnMvdmlkdHYucnN0CgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRh dGlvbi9kcml2ZXItYXBpL21lZGlhL2RyaXZlcnMvaW5kZXgucnN0IGIvRG9jdW1lbnRhdGlvbi9k cml2ZXItYXBpL21lZGlhL2RyaXZlcnMvaW5kZXgucnN0CmluZGV4IDBkZjg1ZmM5NjYwNS4uNWYz NDBjZmRiNGNjIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvbWVkaWEvZHJp dmVycy9pbmRleC5yc3QKKysrIGIvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL21lZGlhL2RyaXZl cnMvaW5kZXgucnN0CkBAIC0zNSw0ICszNSw1IEBAIERpZ2l0YWwgVFYgZHJpdmVycwoKIAlkdmIt dXNiCiAJZnJvbnRlbmRzCisJdmlkdHYKIAljb250cmlidXRvcnMKZGlmZiAtLWdpdCBhL0RvY3Vt ZW50YXRpb24vZHJpdmVyLWFwaS9tZWRpYS9kcml2ZXJzL3ZpZHR2LnJzdCBiL0RvY3VtZW50YXRp b24vZHJpdmVyLWFwaS9tZWRpYS9kcml2ZXJzL3ZpZHR2LnJzdApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAuLjMwMzIyN2E2N2Y2MAotLS0gL2Rldi9udWxsCisrKyBiL0Rv Y3VtZW50YXRpb24vZHJpdmVyLWFwaS9tZWRpYS9kcml2ZXJzL3ZpZHR2LnJzdApAQCAtMCwwICsx LDQxNyBAQAorLi4gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKKworPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KK3ZpZHR2OiBWaXJ0dWFsIERpZ2l0YWwgVFYgZHJpdmVy Cis9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQorCitBdXRob3I6IERhbmllbCBXLiBT LiBBbG1laWRhIDxkd2xzYWxtZWlkYUBnbWFpbC5jb20+LCBKdW5lIDIwMjAuCisKK0JhY2tncm91 bmQKKy0tLS0tLS0tLS0KKworVmlkdHYgaXMgYSB2aXJ0dWFsIERWQiBkcml2ZXIgdGhhdCBhaW1z IHRvIHNlcnZlIGFzIGEgcmVmZXJlbmNlIGZvciBkcml2ZXIKK3dyaXRlcnMgYnkgc2VydmluZyBh cyBhIHRlbXBsYXRlLiBJdCBhbHNvIHZhbGlkYXRlcyB0aGUgZXhpc3RpbmcgbWVkaWEgRFZCCitB UElzLCB0aHVzIGhlbHBpbmcgdXNlcnNwYWNlIGFwcGxpY2F0aW9uIHdyaXRlcnMuCisKK0N1cnJl bnRseSwgaXQgY29uc2lzdHMgb2Y6CisKKy0gQSBmYWtlIHR1bmVyIGRyaXZlciwgd2hpY2ggd2ls bCByZXBvcnQgYSBiYWQgc2lnbmFsIHF1YWxpdHkgaWYgdGhlIGNob3NlbgorICBmcmVxdWVuY3kg aXMgdG9vIGZhciBhd2F5IGZyb20gYSB0YWJsZSBvZiB2YWxpZCBmcmVxdWVuY2llcyBmb3IgYQor ICBwYXJ0aWN1bGFyIGRlbGl2ZXJ5IHN5c3RlbS4KKworLSBBIGZha2UgZGVtb2QgZHJpdmVyLCB3 aGljaCB3aWxsIGNvbnN0YW50bHkgcG9sbCB0aGUgZmFrZSBzaWduYWwgcXVhbGl0eQorICByZXR1 cm5lZCBieSB0aGUgdHVuZXIsIHNpbXVsYXRpbmcgYSBkZXZpY2UgdGhhdCBjYW4gbG9zZS9yZWFj cXVpcmUgYSBsb2NrCisgIG9uIHRoZSBzaWduYWwgZGVwZW5kaW5nIG9uIHRoZSBDTlIgbGV2ZWxz LgorCistIEEgZmFrZSBicmlkZ2UgZHJpdmVyLCB3aGljaCBpcyB0aGUgbW9kdWxlIHJlc3BvbnNp YmxlIGZvciBtb2Rwcm9iaW5nIHRoZQorICBmYWtlIHR1bmVyIGFuZCBkZW1vZCBtb2R1bGVzIGFu ZCBpbXBsZW1lbnRpbmcgdGhlIGRlbXV4IGxvZ2ljLiBUaGlzIG1vZHVsZQorICB0YWtlcyBwYXJh bWV0ZXJzIGF0IGluaXRpYWxpemF0aW9uIHRoYXQgd2lsbCBkaWN0YXRlIGhvdyB0aGUgc2ltdWxh dGlvbgorICBiZWhhdmVzLgorCistIENvZGUgcmVwb25zaWJsZSBmb3IgZW5jb2RpbmcgYSB2YWxp ZCBNUEVHIFRyYW5zcG9ydCBTdHJlYW0sIHdoaWNoIGlzIHRoZW4KKyAgcGFzc2VkIHRvIHRoZSBi cmlkZ2UgZHJpdmVyLiBUaGlzIGZha2Ugc3RyZWFtIGNvbnRhaW5zIHNvbWUgaGFyZGNvZGVkIGNv bnRlbnQuCisgIEZvciBub3csIHdlIGhhdmUgYSBzaW5nbGUsIGF1ZGlvLW9ubHkgY2hhbm5lbCBj b250YWluaW5nIGEgc2luZ2xlIE1QRUcKKyAgRWxlbWVudGFyeSBTdHJlYW0sIHdoaWNoIGluIHR1 cm4gY29udGFpbnMgYSBTTVBURSAzMDJtIGVuY29kZWQgc2luZS13YXZlLgorICBOb3RlIHRoYXQg dGhpcyBwYXJ0aWN1bGFyIGVuY29kZXIgd2FzIGNob3NlbiBiZWNhdXNlIGl0IGlzIHRoZSBlYXNp ZXN0CisgIHdheSB0byBlbmNvZGUgUENNIGF1ZGlvIGRhdGEgaW4gYSBNUEVHIFRyYW5zcG9ydCBT dHJlYW0uCisKK0J1aWxkaW5nIHZpZHR2CistLS0tLS0tLS0tLS0tLQordmlkdHYgaXMgYSB0ZXN0 IGRyaXZlciBhbmQgdGh1cyBpcyAqKm5vdCoqIGVuYWJsZWQgYnkgZGVmYXVsdCB3aGVuCitjb21w aWxpbmcgdGhlIGtlcm5lbC4KKworSW4gb3JkZXIgdG8gZW5hYmxlIGNvbXBpbGF0aW9uIG9mIHZp ZHR2OgorCistIEVuYWJsZSAqKkRWQl9URVNUX0RSSVZFUlMqKiwgdGhlbgorLSBFbmFibGUgKipE VkJfVklEVFYqKgorCitXaGVuIGNvbXBpbGVkIGFzIGEgbW9kdWxlLCBleHBlY3QgdGhlIGZvbGxv d2luZyAua28gZmlsZXM6CisKKy0gZHZiX3ZpZHR2X3R1bmVyLmtvCisKKy0gZHZiX3ZpZHR2X2Rl bW9kLmtvCisKKy0gZHZiX3ZpZHR2X2JyaWRnZS5rbworCitSdW5uaW5nIHZpZHR2CistLS0tLS0t LS0tLS0tCitXaGVuIGNvbXBpbGVkIGFzIGEgbW9kdWxlLCBydW46OgorCisJbW9kcHJvYmUgZHZi X3ZpZHR2X2JyaWRnZQorCitUaGF0J3MgaXQhIFRoZSBicmlkZ2UgZHJpdmVyIHdpbGwgaW5pdGlh bGl6ZSB0aGUgdHVuZXIgYW5kIGRlbW9kIGRyaXZlcnMgYXMKK3BhcnQgb2YgaXRzIG93biBpbml0 aWFsaXphdGlvbi4KKworWW91IGNhbiBvcHRpb25hbGx5IGRlZmluZSBzb21lIGNvbW1hbmQtbGlu ZSBhcmd1bWVudHMgdG8gdmlkdHYuCisKK0NvbW1hbmQtbGluZSBhcmd1bWVudHMgdG8gdmlkdHYK Ky0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KK0JlbG93IGlzIGEgbGlzdCBvZiBhbGwg YXJndW1lbnRzIHRoYXQgY2FuIGJlIHN1cHBsaWVkIHRvIHZpZHR2OgorCitkcm9wX3RzbG9ja19w cm9iX29uX2xvd19zbnIKKwlQcm9iYWJpbGl0eSBvZiBsb3NpbmcgdGhlIFRTIGxvY2sgaWYgdGhl IHNpZ25hbCBxdWFsaXR5IGlzIGJhZC4KKwlUaGlzIHByb2JhYmlsaXR5IGJlIHVzZWQgYnkgdGhl IGZha2UgZGVtb2R1bGF0b3IgZHJpdmVyIHRvCisJZXZlbnR1YWxseSByZXR1cm4gYSBzdGF0dXMg b2YgMCB3aGVuIHRoZSBzaWduYWwgcXVhbGl0eSBpcyBub3QKKwlnb29kLgorCityZWNvdmVyX3Rz bG9ja19wcm9iX29uX2dvb2Rfc25yOgorCVByb2JhYmlsaXR5IHJlY292ZXJpbmcgdGhlIFRTIGxv Y2sgd2hlbiB0aGUgc2lnbmFsIGltcHJvdmVzLiBUaGlzCisJcHJvYmFiaWxpdHkgYmUgdXNlZCBi eSB0aGUgZmFrZSBkZW1vZHVsYXRvciBkcml2ZXIgdG8gZXZlbnR1YWxseQorCXJldHVybiBhIHN0 YXR1cyBvZiAweDFmIHdoZW4vaWYgdGhlIHNpZ25hbCBxdWFsaXR5IGltcHJvdmVzLgorCittb2Nr X3Bvd2VyX3VwX2RlbGF5X21zZWMKKwlTaW11bGF0ZSBhIHBvd2VyIHVwIGRlbGF5LiAgRGVmYXVs dDogMC4KKworbW9ja190dW5lX2RlbGF5X21zZWMKKwlTaW11bGF0ZSBhIHR1bmUgZGVsYXkuICBE ZWZhdWx0IDAuCisKK3ZpZHR2X3ZhbGlkX2R2Yl90X2ZyZXFzCisJVmFsaWQgRFZCLVQgZnJlcXVl bmNpZXMgdG8gc2ltdWxhdGUuCisKK3ZpZHR2X3ZhbGlkX2R2Yl9jX2ZyZXFzCisgCVZhbGlkIERW Qi1DIGZyZXF1ZW5jaWVzIHRvIHNpbXVsYXRlLgorCit2aWR0dl92YWxpZF9kdmJfc19mcmVxcwor CVZhbGlkIERWQi1DIGZyZXF1ZW5jaWVzIHRvIHNpbXVsYXRlLgorCittYXhfZnJlcXVlbmN5X3No aWZ0X2h6LAorCU1heGltdW0gc2hpZnQgaW4gSFogYWxsb3dlZCB3aGVuIHR1bmluZyBpbiBhIGNo YW5uZWwuCisKK3NpX3BlcmlvZF9tc2VjCisJSG93IG9mdGVuIHRvIHNlbmQgU0kgcGFja2V0cy4g IERlZmF1bHQ6IDQwbXMuCisKK3Bjcl9wZXJpb2RfbXNlYworCUhvdyBvZnRlbiB0byBzZW5kIFBD UiBwYWNrZXRzLiAgRGVmYXVsdDogNDBtcy4KKworbXV4X3JhdGVfa2J5dGVzX3NlYworCUF0dGVt cHQgdG8gbWFpbnRhaW4gdGhpcyBiaXQgcmF0ZSBieSBpbnNlcnRpbmcgVFMgbnVsbCBwYWNrZXRz LCBpZgorCW5lY2Vzc2FyeS4gIERlZmF1bHQ6IDQwOTYuCisKK3Bjcl9waWQsCisJUENSIFBJRCBm b3IgYWxsIGNoYW5uZWxzLiAgRGVmYXVsdDogMHgyMDAuCisKK211eF9idWZfc3pfcGt0cywKKwlT aXplIGZvciB0aGUgbXV4IGJ1ZmZlciBpbiBtdWx0aXBsZXMgb2YgMTg4IGJ5dGVzLgorCit2aWR0 diBpbnRlcm5hbCBzdHJ1Y3R1cmUKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorVGhlIGtlcm5l bCBtb2R1bGVzIGFyZSBzcGxpdCBpbiB0aGUgZm9sbG93aW5nIHdheToKKwordmlkdHZfdHVuZXIu W2NoXQorCUltcGxlbWVudHMgYSBmYWtlIHR1bmVyIERWQiBkcml2ZXIuCisKK3ZpZHR2X2RlbW9k LltjaF0KKwlJbXBsZW1lbnRzIGEgZmFrZSBkZW1vZHVsYXRvciBEVkIgZHJpdmVyLgorCit2aWR0 dl9icmlkZ2UuW2NoXQorCUltcGxlbWVudHMgYSBicmlkZ2UgZHJpdmVyLgorCitUaGUgTVBFRyBy ZWxhdGVkIGNvZGUgaXMgc3BsaXQgaW4gdGhlIGZvbGxvd2luZyB3YXk6CisKK3ZpZHR2X3RzLltj aF0KKwlDb2RlIHRvIHdvcmsgd2l0aCBNUEVHIFRTIHBhY2tldHMsIHN1Y2ggYXMgVFMgaGVhZGVy cywgYWRhcHRhdGlvbgorCWZpZWxkcywgUENSIHBhY2tldHMgYW5kIE5VTEwgcGFja2V0cy4KKwor dmlkdHZfcHNpLltjaF0KKwlUaGlzIGlzIHRoZSBQU0kgZ2VuZXJhdG9yLiAgUFNJIHBhY2tldHMg Y29udGFpbiBnZW5lcmFsIGluZm9ybWF0aW9uCisJYWJvdXQgYSBNUEVHIFRyYW5zcG9ydCBTdHJl YW0uICBBIFBTSSBnZW5lcmF0b3IgaXMgbmVlZGVkIHNvCisJdXNlcnNwYWNlIGFwcHMgY2FuIHJl dHJpZXZlIGluZm9ybWF0aW9uIGFib3V0IHRoZSBUcmFuc3BvcnQgU3RyZWFtCisJYW5kIGV2ZW50 dWFsbHkgdHVuZSBpbnRvIGEgKGR1bW15KSBjaGFubmVsLgorCisJQmVjYXVzZSB0aGUgZ2VuZXJh dG9yIGlzIGltcGxlbWVudGVkIGluIGEgc2VwYXJhdGUgZmlsZSwgaXQgY2FuIGJlCisJcmV1c2Vk IGVsc2V3aGVyZSBpbiB0aGUgbWVkaWEgc3Vic3lzdGVtLgorCisJQ3VycmVudGx5IHZpZHR2IHN1 cHBvcnRzIHdvcmtpbmcgd2l0aCAzIFBTSSB0YWJsZXM6IFBBVCwgUE1UIGFuZAorCVNEVC4KKwor CVRoZSBzcGVjaWZpY2F0aW9uIGZvciBQQVQgYW5kIFBNVCBjYW4gYmUgZm91bmQgaW4gKklTTyAx MzgxOC0xOgorCVN5c3RlbXMqLCB3aGlsZSB0aGUgc3BlY2lmaWNhdGlvbiBmb3IgdGhlIFNEVCBj YW4gYmUgZm91bmQgaW4gKkVUU0kKKwlFTiAzMDAgNDY4OiBTcGVjaWZpY2F0aW9uIGZvciBTZXJ2 aWNlIEluZm9ybWF0aW9uIChTSSkgaW4gRFZCCisJc3lzdGVtcyouCisKKwlJdCBpc24ndCBzdHJp Y3RseSBuZWNlc3NhcnksIGJ1dCB1c2luZyBhIHJlYWwgVFMgZmlsZSBoZWxwcyB3aGVuCisJZGVi dWdnaW5nIFBTSSB0YWJsZXMuIFZpZHR2IGN1cnJlbnRseSB0cmllcyB0byByZXBsaWNhdGUgdGhl IFBTSQorCXN0cnVjdHVyZSBmb3VuZCBpbiB0aGlzIGZpbGU6IGBUUzFHbG9iby50cworCTxodHRw czovL3RzZHVjay5pby9zdHJlYW1zL2JyYXppbC1pc2RiLXRiL1RTMWdsb2JvLnRzPmBfLgorCisJ QSBnb29kIHdheSB0byB2aXN1YWxpemUgdGhlIHN0cnVjdHVyZSBvZiBzdHJlYW1zIGlzIGJ5IHVz aW5nCisJYERWQkluc3BlY3RvciA8aHR0cHM6Ly9zb3VyY2Vmb3JnZS5uZXQvcHJvamVjdHMvZHZi aW5zcGVjdG9yLz5gXy4KKwordmlkdHZfcGVzLltjaF0KKwlJbXBsZW1lbnRzIHRoZSBQRVMgbG9n aWMgdG8gY29udmVydCBlbmNvZGVyIGRhdGEgaW50byBNUEVHIFRTCisJcGFja2V0cy4gVGhlc2Ug Y2FuIHRoZW4gYmUgZmVkIGludG8gYSBUUyBtdWx0aXBsZXhlciBhbmQgZXZlbnR1YWxseQorCWlu dG8gdXNlcnNwYWNlLgorCit2aWR0dl9lbmNvZGVyLmgKKwlBbiBpbnRlcmZhY2UgZm9yIHZpZHR2 IGVuY29kZXJzLiBOZXcgZW5jb2RlcnMgY2FuIGJlIGFkZGVkIHRvIHRoaXMKKwlkcml2ZXIgYnkg aW1wbGVtZW50aW5nIHRoZSBjYWxscyBpbiB0aGlzIGZpbGUuCisKK3ZpZHR2X3MzMDJtLltjaF0K KwlJbXBsZW1lbnRzIGEgUzMwMk0gZW5jb2RlciB0byBtYWtlIGl0IHBvc3NpYmxlIHRvIGluc2Vy dCBQQ00gYXVkaW8KKwlkYXRhIGluIHRoZSBnZW5lcmF0ZWQgTVBFRyBUcmFuc3BvcnQgU3RyZWFt LiBUaGUgcmVsZXZhbnQKKwlzcGVjaWZpY2F0aW9uIGlzIGF2YWlsYWJsZSBvbmxpbmUgYXMgKlNN UFRFIDMwMk0tMjAwNzogVGVsZXZpc2lvbiAtCisJTWFwcGluZyBvZiBBRVMzIERhdGEgaW50byBN UEVHLTIgVHJhbnNwb3J0IFN0cmVhbSouCisKKworCVRoZSByZXN1bHRpbmcgTVBFRyBFbGVtZW50 YXJ5IFN0cmVhbSBpcyBjb252ZXllZCBpbiBhIHByaXZhdGUKKwlzdHJlYW0gd2l0aCBhIFMzMDJN IHJlZ2lzdHJhdGlvbiBkZXNjcmlwdG9yIGF0dGFjaGVkLgorCisJVGhpcyBzaGFsbCBlbmFibGUg cGFzc2luZyBhbiBhdWRpbyBzaWduYWwgaW50byB1c2Vyc3BhY2Ugc28gaXQgY2FuCisJYmUgZGVj b2RlZCBhbmQgcGxheWVkIGJ5IG1lZGlhIHNvZnR3YXJlLiBUaGUgY29ycmVzcG9uZGluZyBkZWNv ZGVyCisJaW4gZmZtcGVnIGlzIGxvY2F0ZWQgaW4gJ2xpYmF2Y29kZWMvczMwMm0uYycgYW5kIGlz IGV4cGVyaW1lbnRhbC4KKwordmlkdHZfY2hhbm5lbC5bY2hdCisJSW1wbGVtZW50cyBhICdjaGFu bmVsJyBhYnN0cmFjdGlvbi4KKworCVdoZW4gdmlkdHYgYm9vdHMsIGl0IHdpbGwgY3JlYXRlIHNv bWUgaGFyZGNvZGVkIGNoYW5uZWxzOgorCisJIy4gVGhlaXIgc2VydmljZXMgd2lsbCBiZSBjb25j YXRlbmF0ZWQgdG8gcG9wdWxhdGUgdGhlIFNEVC4KKworCSMuIFRoZWlyIHByb2dyYW1zIHdpbGwg YmUgY29uY2F0ZW5hdGVkIHRvIHBvcHVsYXRlIHRoZSBQQVQKKworCSMuIEZvciBlYWNoIHByb2dy YW0gaW4gdGhlIFBBVCwgYSBQTVQgc2VjdGlvbiB3aWxsIGJlIGNyZWF0ZWQKKworCSMuIFRoZSBQ TVQgc2VjdGlvbiBmb3IgYSBjaGFubmVsIHdpbGwgYmUgYXNzaWduZWQgaXRzIHN0cmVhbXMuCisK KwkjLiBFdmVyeSBzdHJlYW0gd2lsbCBoYXZlIGl0cyBjb3JyZXNwb25kaW5nIGVuY29kZXIgcG9s bGVkIGluIGEKKwkgICBsb29wIHRvIHByb2R1Y2UgVFMgcGFja2V0cy4KKwkgICBUaGVzZSBwYWNr ZXRzIG1heSBiZSBpbnRlcmxlYXZlZCBieSB0aGUgbXV4ZXIgYW5kIHRoZW4gZGVsaXZlcmVkCisJ ICAgdG8gdGhlIGJyaWRnZS4KKwordmlkdHZfbXV4LltjaF0KKwlJbXBsZW1lbnRzIGEgTVBFRyBU UyBtdXgsIGxvb3NlbHkgYmFzZWQgb24gdGhlIGZmbXBlZworCWltcGxlbWVudGF0aW9uIGluICJs aWJhdmNvZGVjL21wZWd0c2VuYy5jIgorCisJVGhlIG11eGVyIHJ1bnMgYSBsb29wIHdoaWNoIGlz IHJlc3BvbnNpYmxlIGZvcjoKKworCSMuIEtlZXBpbmcgdHJhY2sgb2YgdGhlIGFtb3VudCBvZiB0 aW1lIGVsYXBzZWQgc2luY2UgdGhlIGxhc3QKKwkgICBpdGVyYXRpb24uCisKKwkjLiBQb2xsaW5n IGVuY29kZXJzIGluIG9yZGVyIHRvIGZldGNoICdlbGFwc2VkX3RpbWUnIHdvcnRoIG9mIGRhdGEu CisKKwkjLiBJbnNlcnRpbmcgUFNJIGFuZC9vciBQQ1IgcGFja2V0cywgaWYgbmVlZGVkLgorCisJ Iy4gUGFkZGluZyB0aGUgcmVzdWx0aW5nIHN0cmVhbSB3aXRoIE5VTEwgcGFja2V0cyBpZgorCSAg IG5lY2Vzc2FyeSBpbiBvcmRlciB0byBtYWludGFpbiB0aGUgY2hvc2VuIGJpdCByYXRlLgorCisJ Iy4gRGVsaXZlcmluZyB0aGUgcmVzdWx0aW5nIFRTIHBhY2tldHMgdG8gdGhlIGJyaWRnZQorCSAg IGRyaXZlciBzbyBpdCBjYW4gcGFzcyB0aGVtIHRvIHRoZSBkZW11eC4KKworVGVzdGluZyB2aWR0 diB3aXRoIHY0bC11dGlscworLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCitVc2luZyB0 aGUgdG9vbHMgaW4gdjRsLXV0aWxzIGlzIGEgZ3JlYXQgd2F5IHRvIHRlc3QgYW5kIGluc3BlY3Qg dGhlIG91dHB1dCBvZgordmlkdHYuIEl0IGlzIGhvc3RlZCBoZXJlOiBgdjRsLXV0aWxzIERvY3Vt ZW50YXRpb24KKzxodHRwczovL2xpbnV4dHYub3JnL3dpa2kvaW5kZXgucGhwL1Y0bC11dGlscz5g Xy4KKworRnJvbSBpdHMgd2VicGFnZTo6CisKKwlUaGUgdjRsLXV0aWxzIGFyZSBhIHNlcmllcyBv ZiBwYWNrYWdlcyBmb3IgaGFuZGxpbmcgbWVkaWEgZGV2aWNlcy4KKworCUl0IGlzIGhvc3RlZCBh dCBodHRwOi8vZ2l0LmxpbnV4dHYub3JnL3Y0bC11dGlscy5naXQsIGFuZCBwYWNrYWdlZAorCW9u IG1vc3QgZGlzdHJpYnV0aW9ucy4KKworCUl0IHByb3ZpZGVzIGEgc2VyaWVzIG9mIGxpYnJhcmll cyBhbmQgdXRpbGl0aWVzIHRvIGJlIHVzZWQgdG8KKwljb250cm9sIHNldmVyYWwgYXNwZWN0IG9m IHRoZSBtZWRpYSBib2FyZHMuCisKKworU3RhcnQgYnkgaW5zdGFsbGluZyB2NGwtdXRpbHMgYW5k IHRoZW4gbW9kcHJvYmluZyB2aWR0djo6CisKKwltb2Rwcm9iZSBkdmJfdmlkdHZfYnJpZGdlCisK K0lmIHRoZSBkcml2ZXIgaXMgT0ssIGl0IHNob3VsZCBsb2FkIGFuZCBpdHMgcHJvYmluZyBjb2Rl IHdpbGwgcnVuLiBUaGlzIHdpbGwKK3B1bGwgaW4gdGhlIHR1bmVyIGFuZCBkZW1vZCBkcml2ZXJz LgorCitVc2luZyBkdmItZmUtdG9vbAorfn5+fn5+fn5+fn5+fn5+fn4KKworVGhlIGZpcnN0IHN0 ZXAgdG8gY2hlY2sgd2hldGhlciB0aGUgZGVtb2QgbG9hZGVkIHN1Y2Nlc3NmdWxseSBpcyB0byBy dW46OgorCisJJCBkdmItZmUtdG9vbAorCitUaGlzIHNob3VsZCByZXR1cm4gd2hhdCBpcyBjdXJy ZW50bHkgc2V0IHVwIGF0IHRoZSBkZW1vZCBzdHJ1Y3QsIGkuZS46OgorCisJc3RhdGljIGNvbnN0 IHN0cnVjdCBkdmJfZnJvbnRlbmRfb3BzIHZpZHR2X2RlbW9kX29wcyA9IHsKKwkJLmRlbHN5cyA9 IHsKKwkJCVNZU19EVkJULAorCQkJU1lTX0RWQlQyLAorCQkJU1lTX0RWQkNfQU5ORVhfQSwKKwkJ CVNZU19EVkJTLAorCQkJU1lTX0RWQlMyLAorCQl9LAorCisJCS5pbmZvID0geworCQkJLm5hbWUg ICAgICAgICAgICAgICAgICAgPSAiRHVtbXkgZGVtb2QgZm9yIERWQi1UL1QyL0MvUy9TMiIsCisJ CQkuZnJlcXVlbmN5X21pbl9oeiAgICAgICA9IDUxICogTUh6LAorCQkJLmZyZXF1ZW5jeV9tYXhf aHogICAgICAgPSAyMTUwICogTUh6LAorCQkJLmZyZXF1ZW5jeV9zdGVwc2l6ZV9oeiAgPSA2MjUw MCwKKwkJCS5mcmVxdWVuY3lfdG9sZXJhbmNlX2h6ID0gMjk1MDAgKiBrSHosCisJCQkuc3ltYm9s X3JhdGVfbWluICAgICAgICA9IDEwMDAwMDAsCisJCQkuc3ltYm9sX3JhdGVfbWF4ICAgICAgICA9 IDQ1MDAwMDAwLAorCisJCQkuY2FwcyA9IEZFX0NBTl9GRUNfMV8yIHwKKwkJCQlGRV9DQU5fRkVD XzJfMyB8CisJCQkJRkVfQ0FOX0ZFQ18zXzQgfAorCQkJCUZFX0NBTl9GRUNfNF81IHwKKwkJCQlG RV9DQU5fRkVDXzVfNiB8CisJCQkJRkVfQ0FOX0ZFQ182XzcgfAorCQkJCUZFX0NBTl9GRUNfN184 IHwKKwkJCQlGRV9DQU5fRkVDXzhfOSB8CisJCQkJRkVfQ0FOX1FBTV8xNiB8CisJCQkJRkVfQ0FO X1FBTV82NCB8CisJCQkJRkVfQ0FOX1FBTV8zMiB8CisJCQkJRkVfQ0FOX1FBTV8xMjggfAorCQkJ CUZFX0NBTl9RQU1fMjU2IHwKKwkJCQlGRV9DQU5fUUFNX0FVVE8gfAorCQkJCUZFX0NBTl9RUFNL IHwKKwkJCQlGRV9DQU5fRkVDX0FVVE8gfAorCQkJCUZFX0NBTl9JTlZFUlNJT05fQVVUTyB8CisJ CQkJRkVfQ0FOX1RSQU5TTUlTU0lPTl9NT0RFX0FVVE8gfAorCQkJCUZFX0NBTl9HVUFSRF9JTlRF UlZBTF9BVVRPIHwKKwkJCQlGRV9DQU5fSElFUkFSQ0hZX0FVVE8sCisJCX0KKworCQkuLi4uCisK K0ZvciBtb3JlIGluZm9ybWF0aW9uIG9uIGR2Yi1mZS10b29scyBjaGVjayBpdHMgb25saW5lIGRv Y3VtZW50YXRpb24gaGVyZToKK2BkdmItZmUtdG9vbCBEb2N1bWVudGF0aW9uCis8aHR0cHM6Ly93 d3cubGludXh0di5vcmcvd2lraS9pbmRleC5waHAvRHZiLWZlLXRvb2w+YF8uCisKK1VzaW5nIGR2 Yi1zY2FuCit+fn5+fn5+fn5+fn5+fgorCitJbiBvcmRlciB0byB0dW5lIGludG8gYSBjaGFubmVs IGFuZCByZWFkIHRoZSBQU0kgdGFibGVzLCB3ZSBjYW4gdXNlIGR2Yi1zY2FuLgorCitGb3IgdGhp cywgb25lIHNob3VsZCBwcm92aWRlIGEgY29uZmlndXJhdGlvbiBmaWxlIGtub3duIGFzIGEgJ3Nj YW4gZmlsZScsCitoZXJlJ3MgYW4gZXhhbXBsZTo6CisKKwlbQ2hhbm5lbF0KKwlGUkVRVUVOQ1kg PSAzMzAwMDAwMDAKKwlNT0RVTEFUSU9OID0gUUFNL0FVVE8KKwlTWU1CT0xfUkFURSA9IDY5NDAw MDAKKwlJTk5FUl9GRUMgPSBBVVRPCisJREVMSVZFUllfU1lTVEVNID0gRFZCQy9BTk5FWF9BCisK Ky4uIG5vdGU6OgorCVRoZSBwYXJhbWV0ZXJzIGRlcGVuZCBvbiB0aGUgdmlkZW8gc3RhbmRhcmQg eW91J3JlIHRlc3RpbmcuCisKKy4uIG5vdGU6OgorCVZpZHR2IGlzIGEgZmFrZSBkcml2ZXIgYW5k IGRvZXMgbm90IHZhbGlkYXRlIG11Y2ggb2YgdGhlIGluZm9ybWF0aW9uCisJaW4gdGhlIHNjYW4g ZmlsZS4gSnVzdCBzcGVjaWZ5aW5nICdGUkVRVUVOQ1knIGFuZCAnREVMSVZFUllfU1lTVEVNJwor CXNob3VsZCBiZSBlbm91Z2ggZm9yIERWQi1UL0RWQi1UMi4gRm9yIERWQi1TL0RWQi1DIGhvd2V2 ZXIsIHlvdQorCXNob3VsZCBhbHNvIHByb3ZpZGUgJ1NZTUJPTF9SQVRFJy4KKworWW91IGNhbiBi cm93c2Ugc2NhbiB0YWJsZXMgb25saW5lIGhlcmU6IGBkdmItc2Nhbi10YWJsZXMKKzxodHRwczov L2dpdC5saW51eHR2Lm9yZy9kdHYtc2Nhbi10YWJsZXMuZ2l0PmBfLgorCitBc3N1bWluZyB0aGlz IGNoYW5uZWwgaXMgbmFtZWQgJ2NoYW5uZWwuY29uZicsIHlvdSBjYW4gdGhlbiBydW46OgorCisg ICAgICAgICQgZHZidjUtc2NhbiBjaGFubmVsLmNvbmYKKworRm9yIG1vcmUgaW5mb3JtYXRpb24g b24gZHZiLXNjYW4sIGNoZWNrIGl0cyBkb2N1bWVudGF0aW9uIG9ubGluZSBoZXJlOgorYGR2Yi1z Y2FuIERvY3VtZW50YXRpb24gPGh0dHBzOi8vd3d3LmxpbnV4dHYub3JnL3dpa2kvaW5kZXgucGhw L0R2YnNjYW4+YF8uCisKK1VzaW5nIGR2Yi16YXAKK35+fn5+fn5+fn5+fn4KKworZHZidjUtemFw IGlzIGEgY29tbWFuZCBsaW5lIHRvb2wgdGhhdCBjYW4gYmUgdXNlZCB0byByZWNvcmQgTVBFRy1U UyB0byBkaXNrLiBUaGUKK3R5cGljYWwgdXNlIGlzIHRvIHR1bmUgaW50byBhIGNoYW5uZWwgYW5k IHB1dCBpdCBpbnRvIHJlY29yZCBtb2RlLiBUaGUgZXhhbXBsZQorYmVsb3cgLSB3aGljaCBpcyB0 YWtlbiBmcm9tIHRoZSBkb2N1bWVudGF0aW9uIC0gaWxsdXN0cmF0ZXMgdGhhdDo6CisKKyAgICAg ICAgJCBkdmJ2NS16YXAgLWMgZHZiX2NoYW5uZWwuY29uZiAidHJpbGhhcyBzb25vcmFzIiAtcgor ICAgICAgICB1c2luZyBkZW11eCAnL2Rldi9kdmIvYWRhcHRlcjAvZGVtdXgwJworICAgICAgICBy ZWFkaW5nIGNoYW5uZWxzIGZyb20gZmlsZSAnZHZiX2NoYW5uZWwuY29uZicKKyAgICAgICAgc2Vy dmljZSBoYXMgcGlkIHR5cGUgMDU6ICAyMDQKKyAgICAgICAgdHVuaW5nIHRvIDU3MzAwMDAwMCBI egorICAgICAgICBhdWRpbyBwaWQgMTA0CisgICAgICAgICAgZHZiX3NldF9wZXNmaWx0ZXIgMTA0 CisgICAgICAgIExvY2sgICAoMHgxZikgUXVhbGl0eT0gR29vZCBTaWduYWw9IDEwMC4wMCUgQy9O PSAtMTMuODBkQiBVQ0I9IDcwIHBvc3RCRVI9IDMuMTR4MTBeLTMgUEVSPSAwCisgICAgICAgIERW UiBpbnRlcmZhY2UgJy9kZXYvZHZiL2FkYXB0ZXIwL2R2cjAnIGNhbiBub3cgYmUgb3BlbmVkCisK K1RoZSBjaGFubmVsIGNhbiBiZSB3YXRjaGVkIGJ5IHBsYXlpbmcgdGhlIGNvbnRlbnRzIG9mIHRo ZSBEVlIgaW50ZXJmYWNlLCB3aXRoCitzb21lIHBsYXllciB0aGF0IHJlY29nbml6ZXMgdGhlIE1Q RUctVFMgZm9ybWF0LCBzdWNoIGFzICptcGxheWVyKiBvciAqdmxjKi4KKworQnkgcGxheWluZyB0 aGUgY29udGVudHMgb2YgdGhlIHN0cmVhbSBvbmUgY2FuIHZpc3VhbGx5IGluc3BlY3QgdGhlIHdv cmtpbmdzIG9mCit2aWR0diwgZS5nLjo6CisKKwkkIG1wbGF5ZXIgL2Rldi9kdmIvYWRhcHRlcjAv ZHZyMAorCitGb3IgbW9yZSBpbmZvcm1hdGlvbiBvbiBkdmItemFwIGNoZWNrIGl0cyBvbmxpbmUg ZG9jdW1lbnRhdGlvbiBoZXJlOgorYGR2Yi16YXAgRG9jdW1lbnRhdGlvbgorPGh0dHBzOi8vd3d3 LmxpbnV4dHYub3JnL3dpa2kvaW5kZXgucGhwL0R2YnY1LXphcD5gXy4KK1NlZSBhbHNvOiBgemFw IDxodHRwczovL3d3dy5saW51eHR2Lm9yZy93aWtpL2luZGV4LnBocC9aYXA+YF8uCisKKworV2hh dCBjYW4gc3RpbGwgYmUgaW1wcm92ZWQgaW4gdmlkdHYKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tCisKK0FkZCAqZGVidWdmcyogaW50ZWdyYXRpb24KK35+fn5+fn5+fn5+fn5+ fn5+fn5+fn5+fn4KKworQWx0aG91Z2ggZnJvbnRlbmQgZHJpdmVycyBwcm92aWRlIERWQnY1IHN0 YXRpc3RpY3MgdmlhIHRoZSAucmVhZF9zdGF0dXMKK2NhbGwsIGEgbmljZSBhZGRpdGlvbiB3b3Vs ZCBiZSB0byBtYWtlIGFkZGl0aW9uYWwgc3RhdGlzdGljcyBhdmFpbGFibGUgdG8KK3VzZXJzcGFj ZSB2aWEgZGVidWdmcywgd2hpY2ggaXMgYSBzaW1wbGUtdG8tdXNlLCBSQU0tYmFzZWQgZmlsZXN5 c3RlbQorc3BlY2lmaWNhbGx5IGRlc2lnbmVkIGZvciBkZWJ1ZyBwdXJwb3Nlcy4KKworVGhlIGxv Z2ljIGZvciB0aGlzIHdvdWxkIGJlIGltcGxlbWVudGVkIG9uIGEgc2VwYXJhdGUgZmlsZSBzbyBh cyBub3QgdG8KK3BvbGx1dGUgdGhlIGZyb250ZW5kIGRyaXZlci4gIFRoZXNlIHN0YXRpc3RpY3Mg YXJlIGRyaXZlci1zcGVjaWZpYyBhbmQgY2FuCitiZSB1c2VmdWwgZHVyaW5nIHRlc3RzLgorCitU aGUgU2lhbm8gZHJpdmVyIGlzIG9uZSBleGFtcGxlIG9mIGEgZHJpdmVyIHVzaW5nCitkZWJ1Z2Zz IHRvIGNvbnZleSBkcml2ZXItc3BlY2lmaWMgc3RhdGlzdGljcyB0byB1c2Vyc3BhY2UgYW5kIGl0 IGNhbiBiZQordXNlZCBhcyBhIHJlZmVyZW5jZS4KKworVGhpcyBzaG91bGQgYmUgZnVydGhlciBl bmFibGVkIGFuZCBkaXNhYmxlZCB2aWEgYSBLY29uZmlnCitvcHRpb24gZm9yIGNvbnZlbmllbmNl LgorCitBZGQgYSB3YXkgdG8gdGVzdCB2aWRlbworfn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KKwor Q3VycmVudGx5LCB2aWR0diBjYW4gb25seSBlbmNvZGUgUENNIGF1ZGlvLiBJdCB3b3VsZCBiZSBn cmVhdCB0byBpbXBsZW1lbnQKK2EgYmFyZWJvbmVzIHZlcnNpb24gb2YgTVBFRy0yIHZpZGVvIGVu Y29kaW5nIHNvIHdlIGNhbiBhbHNvIHRlc3QgdmlkZW8uIFRoZQorZmlyc3QgcGxhY2UgdG8gbG9v ayBpbnRvIGlzICpJU08gMTM4MTgtMjogSW5mb3JtYXRpb24gdGVjaG5vbG9neSDigJQgR2VuZXJp YworY29kaW5nIG9mIG1vdmluZyBwaWN0dXJlcyBhbmQgYXNzb2NpYXRlZCBhdWRpbyBpbmZvcm1h dGlvbiDigJQgUGFydCAyOiBWaWRlbyosCit3aGljaCBjb3ZlcnMgdGhlIGVuY29kaW5nIG9mIGNv bXByZXNzZWQgdmlkZW8gaW4gTVBFRyBUcmFuc3BvcnQgU3RyZWFtcy4KKworVGhpcyBtaWdodCBv cHRpb25hbGx5IHVzZSB0aGUgVmlkZW80TGludXgyIFRlc3QgUGF0dGVybiBHZW5lcmF0b3IsIHY0 bDItdHBnLAord2hpY2ggcmVzaWRlcyBhdDo6CisKKwlkcml2ZXJzL21lZGlhL2NvbW1vbi92NGwy LXRwZy8KKworCitBZGQgd2hpdGUgbm9pc2Ugc2ltdWxhdGlvbgorfn5+fn5+fn5+fn5+fn5+fn5+ fn5+fn5+fn4KKworVGhlIHZpZHR2IHR1bmVyIGFscmVhZHkgaGFzIGNvZGUgdG8gaWRlbnRpZnkg d2hldGhlciB0aGUgY2hvc2VuIGZyZXF1ZW5jeQoraXMgdG9vIGZhciBhd2F5IGZyb20gYSB0YWJs ZSBvZiB2YWxpZCBmcmVxdWVuY2llcy4gRm9yIG5vdywgdGhpcyBtZWFucyB0aGF0Cit0aGUgZGVt b2R1bGF0b3IgY2FuIGV2ZW50dWFsbHkgbG9zZSB0aGUgbG9jayBvbiB0aGUgc2lnbmFsLCBzaW5j ZSB0aGUgdHVuZXIgd2lsbAorcmVwb3J0IGEgYmFkIHNpZ25hbCBxdWFsaXR5LgorCitBIG5pY2Ug YWRkaXRpb24gaXMgdG8gc2ltdWxhdGUgc29tZSBub2lzZSB3aGVuIHRoZSBzaWduYWwgcXVhbGl0 eSBpcyBiYWQgYnk6CisKKy0gUmFuZG9tbHkgZHJvcHBpbmcgc29tZSBUUyBwYWNrZXRzLiBUaGlz IHdpbGwgdHJpZ2dlciBhIGNvbnRpbnVpdHkgZXJyb3IgaWYgdGhlCisgIGNvbnRpbnVpdHkgY291 bnRlciBpcyB1cGRhdGVkIGJ1dCB0aGUgcGFja2V0IGlzIG5vdCBwYXNzZWQgb24gdG8gdGhlIGRl bXV4LgorCistIFVwZGF0aW5nIHRoZSBlcnJvciBzdGF0aXN0aWNzIGFjY29yZGluZ2x5IChlLmcu IEJFUiwgZXRjKS4KKworLSBTaW11bGF0aW5nIHNvbWUgbm9pc2UgaW4gdGhlIGVuY29kZWQgZGF0 YS4KLS0KMi4yOC4wCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fXwpMaW51eC1rZXJuZWwtbWVudGVlcyBtYWlsaW5nIGxpc3QKTGludXgta2VybmVsLW1lbnRl ZXNAbGlzdHMubGludXhmb3VuZGF0aW9uLm9yZwpodHRwczovL2xpc3RzLmxpbnV4Zm91bmRhdGlv bi5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1rZXJuZWwtbWVudGVlcwo=