44995 2010-08-31 14:59:43 -0700 Add AudioParam files 2010-09-03 12:24:41 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Other OS X 10.5 RESOLVED FIXED P2 Normal --- 0 crogers webkit-unassigned cmarrin dglazkov eric.carlson japhet jer.noble kbr simon.fraser oldest_to_newest 272415 0 crogers 2010-08-31 14:59:43 -0700 Add AudioParam files 272417 1 66119 crogers 2010-08-31 15:01:31 -0700 Created attachment 66119 Patch 272420 2 crogers 2010-08-31 15:02:22 -0700 This implements AudioParam as defined in the web audio specification: http://chromium.googlecode.com/svn/trunk/samples/audio/specification/specification.html#AudioParam-section 273669 3 66119 kbr 2010-09-02 16:40:49 -0700 Comment on attachment 66119 Patch Marking r+ with a few minor comments. Fix upon committing, or upload new patch. > Index: WebCore/webaudio/AudioParam.h > =================================================================== > --- WebCore/webaudio/AudioParam.h (revision 0) > +++ WebCore/webaudio/AudioParam.h (revision 0) > @@ -0,0 +1,115 @@ > +/* > + * Copyright (C) 2010 Google Inc. All rights reserved. > + * > + * Redistribution and use in source and binary forms, with or without > + * modification, are permitted provided that the following conditions > + * are met: > + * > + * 1. Redistributions of source code must retain the above copyright > + * notice, this list of conditions and the following disclaimer. > + * 2. Redistributions in binary form must reproduce the above copyright > + * notice, this list of conditions and the following disclaimer in the > + * documentation and/or other materials provided with the distribution. > + * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of > + * its contributors may be used to endorse or promote products derived > + * from this software without specific prior written permission. > + * > + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY > + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED > + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE > + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY > + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES > + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; > + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND > + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT > + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF > + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. > + */ > + > +#ifndef AudioParam_h > +#define AudioParam_h > + > +#include "PlatformString.h" > +#include <math.h> > +#include <sys/types.h> > +#include <wtf/PassRefPtr.h> > +#include <wtf/RefCounted.h> > + > +namespace WebCore { > + > +class AudioParam : public RefCounted<AudioParam> { > +public: > + static const double DefaultSmoothingConstant = 0.05; > + static const double SnapThreshold = 0.001; I think you're going to have problems getting this to link on all platforms (or maybe not, since you're developing on the Mac and clearly things are linking for you). I believe you need the following in an AudioParam.cc for correctness. // GCC requires these declarations, but MSVC requires they not be present #ifndef COMPILER_MSVC const double AudioParam::DefaultSmoothingConstant; const double AudioParam::SnapThreshold; #endif It might only be necessary if these are referenced from another .cpp file; not sure. It looks like SnapThreshold doesn't need to be accessed from outside this class in which case it should be private. If the same is true for DefaultSmoothingConstant then making them both private may solve the problem. > + > + static PassRefPtr<AudioParam> create(const String& name, double defaultValue, double minValue, double maxValue, unsigned units = 0) > + { > + return adoptRef(new AudioParam(name, defaultValue, minValue, maxValue, units)); > + } > + > + AudioParam(const String& name, double defaultValue, double minValue, double maxValue, unsigned units = 0) > + : m_name(name) > + , m_value(defaultValue) > + , m_defaultValue(defaultValue) > + , m_minValue(minValue) > + , m_maxValue(maxValue) > + , m_units(units) > + , m_smoothedValue(defaultValue) > + , m_smoothingConstant(DefaultSmoothingConstant) > + { > + } > + > + float value() const { return static_cast<float>(m_value); } > + void setValue(float value) { m_value = value; } > + > + String name() const { return m_name; } > + > + float minValue() const { return static_cast<float>(m_minValue); } > + float maxValue() const { return static_cast<float>(m_maxValue); } > + float defaultValue() const { return static_cast<float>(m_defaultValue); } > + unsigned units() const { return m_units; } I'd add a FIXME here too about defining units. > + > + // Value smoothing: > + > + // When a new value is set with setValue(), in our internal use of the parameter we don't immediately jump to it. > + // Instead we smoothly approach this value to avoid glitching. > + float smoothedValue() const { return static_cast<float>(m_smoothedValue); } These casts between floats and doubles are verbose. I think you should consider changing all of these implementing classes to use floats internally rather than doubles, and pass floats around in the API. > + > + // Smoothly exponentially approaches to (de-zippers) the desired value. > + // Returns true if smoothed value has already snapped exactly to value. > + bool smooth() > + { > + if (m_smoothedValue == m_value) { > + // Smoothed value has already approached and snapped to value. > + return true; > + } > + > + // Exponential approach > + m_smoothedValue += (m_value - m_smoothedValue) * m_smoothingConstant; > + > + // If we get close enough then snap to actual value. > + if (fabs(m_smoothedValue - m_value) < SnapThreshold) // FIXME: the threshold needs to be adjustable depending on range - but this is OK general purpose value. > + m_smoothedValue = m_value; > + > + return false; > + } > + > + void resetSmoothedValue() { m_smoothedValue = m_value; } > + void setSmoothingConstant(double k) { m_smoothingConstant = k; } > + > +private: > + String m_name; > + double m_value; > + double m_defaultValue; > + double m_minValue; > + double m_maxValue; > + unsigned m_units; > + > + // Smoothing (de-zippering) > + double m_smoothedValue; > + double m_smoothingConstant; > +}; > + > +} // namespace WebCore > + > +#endif // AudioParam_h > Index: WebCore/webaudio/AudioParam.idl > =================================================================== > --- WebCore/webaudio/AudioParam.idl (revision 0) > +++ WebCore/webaudio/AudioParam.idl (revision 0) > @@ -0,0 +1,43 @@ > +/* > + * Copyright (C) 2010 Google Inc. All rights reserved. > + * > + * Redistribution and use in source and binary forms, with or without > + * modification, are permitted provided that the following conditions > + * are met: > + * > + * 1. Redistributions of source code must retain the above copyright > + * notice, this list of conditions and the following disclaimer. > + * 2. Redistributions in binary form must reproduce the above copyright > + * notice, this list of conditions and the following disclaimer in the > + * documentation and/or other materials provided with the distribution. > + * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of > + * its contributors may be used to endorse or promote products derived > + * from this software without specific prior written permission. > + * > + * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY > + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED > + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE > + * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY > + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES > + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; > + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND > + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT > + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF > + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. > + */ > + > +module webaudio { > + interface [ > + Conditional=WEB_AUDIO > + ] AudioParam { > + attribute float value; > + readonly attribute float minValue; > + readonly attribute float maxValue; > + readonly attribute float defaultValue; > + > + readonly attribute DOMString name; > + > + // FIXME: Could define units constants here (seconds, decibels, cents, etc.)... > + readonly attribute unsigned short units; > + }; > +} 274121 4 66119 crogers 2010-09-03 12:24:37 -0700 Comment on attachment 66119 Patch Clearing flags on attachment: 66119 Committed r66759: <http://trac.webkit.org/changeset/66759> 274122 5 crogers 2010-09-03 12:24:41 -0700 All reviewed patches have been landed. Closing bug. 66119 2010-08-31 15:01:31 -0700 2010-09-03 12:24:36 -0700 Patch bug-44995-20100831150130.patch text/plain 8238 crogers SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NjU0MikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjkgQEAKKzIwMTAtMDgtMzEgIENocmlzIFJvZ2VycyAgPGNyb2dlcnNAZ29vZ2xl LmNvbT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBB ZGQgQXVkaW9QYXJhbSBmaWxlcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9NDQ5OTUKKworICAgICAgICBObyBuZXcgdGVzdHMgc2luY2UgYXVkaW8gQVBJ IGlzIG5vdCB5ZXQgaW1wbGVtZW50ZWQuCisKKyAgICAgICAgKiB3ZWJhdWRpbzogQWRkZWQuCisg ICAgICAgICogd2ViYXVkaW8vQXVkaW9QYXJhbS5oOiBBZGRlZC4KKyAgICAgICAgKFdlYkNvcmU6 OkF1ZGlvUGFyYW06OmNyZWF0ZSk6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb1BhcmFtOjpBdWRp b1BhcmFtKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvUGFyYW06OnZhbHVlKToKKyAgICAgICAg KFdlYkNvcmU6OkF1ZGlvUGFyYW06OnNldFZhbHVlKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlv UGFyYW06Om5hbWUpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9QYXJhbTo6bWluVmFsdWUpOgor ICAgICAgICAoV2ViQ29yZTo6QXVkaW9QYXJhbTo6bWF4VmFsdWUpOgorICAgICAgICAoV2ViQ29y ZTo6QXVkaW9QYXJhbTo6ZGVmYXVsdFZhbHVlKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvUGFy YW06OnVuaXRzKToKKyAgICAgICAgKFdlYkNvcmU6OkF1ZGlvUGFyYW06OnNtb290aGVkVmFsdWUp OgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9QYXJhbTo6c21vb3RoKToKKyAgICAgICAgKFdlYkNv cmU6OkF1ZGlvUGFyYW06OnJlc2V0U21vb3RoZWRWYWx1ZSk6CisgICAgICAgIChXZWJDb3JlOjpB dWRpb1BhcmFtOjpzZXRTbW9vdGhpbmdDb25zdGFudCk6CisgICAgICAgICogd2ViYXVkaW8vQXVk aW9QYXJhbS5pZGw6IEFkZGVkLgorCiAyMDEwLTA4LTMxICBFcmljIENhcmxzb24gIDxlcmljLmNh cmxzb25AYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgpJbmRl eDogV2ViQ29yZS93ZWJhdWRpby9BdWRpb1BhcmFtLmgKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS93 ZWJhdWRpby9BdWRpb1BhcmFtLmgJKHJldmlzaW9uIDApCisrKyBXZWJDb3JlL3dlYmF1ZGlvL0F1 ZGlvUGFyYW0uaAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwxMTUgQEAKKy8qCisgKiBDb3B5cmln aHQgKEMpIDIwMTAgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRp c3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdp dGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm b2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqCisgKiAxLiAgUmVkaXN0cmlidXRp b25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIuCisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9k dWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICAgZG9jdW1l bnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1 dGlvbi4KKyAqIDMuICBOZWl0aGVyIHRoZSBuYW1lIG9mIEFwcGxlIENvbXB1dGVyLCBJbmMuICgi QXBwbGUiKSBub3IgdGhlIG5hbWVzIG9mCisgKiAgICAgaXRzIGNvbnRyaWJ1dG9ycyBtYXkgYmUg dXNlZCB0byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZAorICogICAgIGZyb20g dGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4K KyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIEFORCBJVFMgQ09OVFJJ QlVUT1JTICJBUyBJUyIgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMs IElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElF UyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF IEFSRQorICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgT1IgSVRTIENPTlRS SUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQorICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRB TCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKKyAqIChJTkNM VURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsKKyAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORAorICogT04gQU5ZIFRIRU9SWSBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRSBPRgorICogVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIEF1ZGlv UGFyYW1faAorI2RlZmluZSBBdWRpb1BhcmFtX2gKKworI2luY2x1ZGUgIlBsYXRmb3JtU3RyaW5n LmgiCisjaW5jbHVkZSA8bWF0aC5oPgorI2luY2x1ZGUgPHN5cy90eXBlcy5oPgorI2luY2x1ZGUg PHd0Zi9QYXNzUmVmUHRyLmg+CisjaW5jbHVkZSA8d3RmL1JlZkNvdW50ZWQuaD4KKworbmFtZXNw YWNlIFdlYkNvcmUgeworCitjbGFzcyBBdWRpb1BhcmFtIDogcHVibGljIFJlZkNvdW50ZWQ8QXVk aW9QYXJhbT4geworcHVibGljOgorICAgIHN0YXRpYyBjb25zdCBkb3VibGUgRGVmYXVsdFNtb290 aGluZ0NvbnN0YW50ID0gMC4wNTsKKyAgICBzdGF0aWMgY29uc3QgZG91YmxlIFNuYXBUaHJlc2hv bGQgPSAwLjAwMTsKKworICAgIHN0YXRpYyBQYXNzUmVmUHRyPEF1ZGlvUGFyYW0+IGNyZWF0ZShj b25zdCBTdHJpbmcmIG5hbWUsIGRvdWJsZSBkZWZhdWx0VmFsdWUsIGRvdWJsZSBtaW5WYWx1ZSwg ZG91YmxlIG1heFZhbHVlLCB1bnNpZ25lZCB1bml0cyA9IDApCisgICAgeworICAgICAgICByZXR1 cm4gYWRvcHRSZWYobmV3IEF1ZGlvUGFyYW0obmFtZSwgZGVmYXVsdFZhbHVlLCBtaW5WYWx1ZSwg bWF4VmFsdWUsIHVuaXRzKSk7CisgICAgfQorCisgICAgQXVkaW9QYXJhbShjb25zdCBTdHJpbmcm IG5hbWUsIGRvdWJsZSBkZWZhdWx0VmFsdWUsIGRvdWJsZSBtaW5WYWx1ZSwgZG91YmxlIG1heFZh bHVlLCB1bnNpZ25lZCB1bml0cyA9IDApCisgICAgICAgIDogbV9uYW1lKG5hbWUpCisgICAgICAg ICwgbV92YWx1ZShkZWZhdWx0VmFsdWUpCisgICAgICAgICwgbV9kZWZhdWx0VmFsdWUoZGVmYXVs dFZhbHVlKQorICAgICAgICAsIG1fbWluVmFsdWUobWluVmFsdWUpCisgICAgICAgICwgbV9tYXhW YWx1ZShtYXhWYWx1ZSkKKyAgICAgICAgLCBtX3VuaXRzKHVuaXRzKQorICAgICAgICAsIG1fc21v b3RoZWRWYWx1ZShkZWZhdWx0VmFsdWUpCisgICAgICAgICwgbV9zbW9vdGhpbmdDb25zdGFudChE ZWZhdWx0U21vb3RoaW5nQ29uc3RhbnQpCisgICAgeworICAgIH0KKworICAgIGZsb2F0IHZhbHVl KCkgY29uc3QgeyByZXR1cm4gc3RhdGljX2Nhc3Q8ZmxvYXQ+KG1fdmFsdWUpOyB9CisgICAgdm9p ZCBzZXRWYWx1ZShmbG9hdCB2YWx1ZSkgeyBtX3ZhbHVlID0gdmFsdWU7IH0KKworICAgIFN0cmlu ZyBuYW1lKCkgY29uc3QgeyByZXR1cm4gbV9uYW1lOyB9CisKKyAgICBmbG9hdCBtaW5WYWx1ZSgp IGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PGZsb2F0PihtX21pblZhbHVlKTsgfQorICAgIGZs b2F0IG1heFZhbHVlKCkgY29uc3QgeyByZXR1cm4gc3RhdGljX2Nhc3Q8ZmxvYXQ+KG1fbWF4VmFs dWUpOyB9CisgICAgZmxvYXQgZGVmYXVsdFZhbHVlKCkgY29uc3QgeyByZXR1cm4gc3RhdGljX2Nh c3Q8ZmxvYXQ+KG1fZGVmYXVsdFZhbHVlKTsgfQorICAgIHVuc2lnbmVkIHVuaXRzKCkgY29uc3Qg eyByZXR1cm4gbV91bml0czsgfQorCisgICAgLy8gVmFsdWUgc21vb3RoaW5nOgorCisgICAgLy8g V2hlbiBhIG5ldyB2YWx1ZSBpcyBzZXQgd2l0aCBzZXRWYWx1ZSgpLCBpbiBvdXIgaW50ZXJuYWwg dXNlIG9mIHRoZSBwYXJhbWV0ZXIgd2UgZG9uJ3QgaW1tZWRpYXRlbHkganVtcCB0byBpdC4KKyAg ICAvLyBJbnN0ZWFkIHdlIHNtb290aGx5IGFwcHJvYWNoIHRoaXMgdmFsdWUgdG8gYXZvaWQgZ2xp dGNoaW5nLgorICAgIGZsb2F0IHNtb290aGVkVmFsdWUoKSBjb25zdCB7IHJldHVybiBzdGF0aWNf Y2FzdDxmbG9hdD4obV9zbW9vdGhlZFZhbHVlKTsgfQorCisgICAgLy8gU21vb3RobHkgZXhwb25l bnRpYWxseSBhcHByb2FjaGVzIHRvIChkZS16aXBwZXJzKSB0aGUgZGVzaXJlZCB2YWx1ZS4KKyAg ICAvLyBSZXR1cm5zIHRydWUgaWYgc21vb3RoZWQgdmFsdWUgaGFzIGFscmVhZHkgc25hcHBlZCBl eGFjdGx5IHRvIHZhbHVlLgorICAgIGJvb2wgc21vb3RoKCkKKyAgICB7CisgICAgICAgIGlmICht X3Ntb290aGVkVmFsdWUgPT0gbV92YWx1ZSkgeworICAgICAgICAgICAgLy8gU21vb3RoZWQgdmFs dWUgaGFzIGFscmVhZHkgYXBwcm9hY2hlZCBhbmQgc25hcHBlZCB0byB2YWx1ZS4KKyAgICAgICAg ICAgIHJldHVybiB0cnVlOworICAgICAgICB9CisKKyAgICAgICAgLy8gRXhwb25lbnRpYWwgYXBw cm9hY2gKKyAgICAgICAgbV9zbW9vdGhlZFZhbHVlICs9IChtX3ZhbHVlIC0gbV9zbW9vdGhlZFZh bHVlKSAqIG1fc21vb3RoaW5nQ29uc3RhbnQ7CisKKyAgICAgICAgLy8gSWYgd2UgZ2V0IGNsb3Nl IGVub3VnaCB0aGVuIHNuYXAgdG8gYWN0dWFsIHZhbHVlLgorICAgICAgICBpZiAoZmFicyhtX3Nt b290aGVkVmFsdWUgLSBtX3ZhbHVlKSA8IFNuYXBUaHJlc2hvbGQpIC8vIEZJWE1FOiB0aGUgdGhy ZXNob2xkIG5lZWRzIHRvIGJlIGFkanVzdGFibGUgZGVwZW5kaW5nIG9uIHJhbmdlIC0gYnV0IHRo aXMgaXMgT0sgZ2VuZXJhbCBwdXJwb3NlIHZhbHVlLgorICAgICAgICAgICAgbV9zbW9vdGhlZFZh bHVlID0gbV92YWx1ZTsKKworICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQorCisgICAgdm9p ZCByZXNldFNtb290aGVkVmFsdWUoKSB7IG1fc21vb3RoZWRWYWx1ZSA9IG1fdmFsdWU7IH0KKyAg ICB2b2lkIHNldFNtb290aGluZ0NvbnN0YW50KGRvdWJsZSBrKSB7IG1fc21vb3RoaW5nQ29uc3Rh bnQgPSBrOyB9CisKK3ByaXZhdGU6CisgICAgU3RyaW5nIG1fbmFtZTsKKyAgICBkb3VibGUgbV92 YWx1ZTsKKyAgICBkb3VibGUgbV9kZWZhdWx0VmFsdWU7CisgICAgZG91YmxlIG1fbWluVmFsdWU7 CisgICAgZG91YmxlIG1fbWF4VmFsdWU7CisgICAgdW5zaWduZWQgbV91bml0czsKKworICAgIC8v IFNtb290aGluZyAoZGUtemlwcGVyaW5nKQorICAgIGRvdWJsZSBtX3Ntb290aGVkVmFsdWU7Cisg ICAgZG91YmxlIG1fc21vb3RoaW5nQ29uc3RhbnQ7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCisKKyNlbmRpZiAvLyBBdWRpb1BhcmFtX2gKSW5kZXg6IFdlYkNvcmUvd2ViYXVkaW8vQXVk aW9QYXJhbS5pZGwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS93ZWJhdWRpby9BdWRpb1BhcmFtLmlk bAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUvd2ViYXVkaW8vQXVkaW9QYXJhbS5pZGwJKHJldmlz aW9uIDApCkBAIC0wLDAgKzEsNDMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTAgR29vZ2xl IEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNl IGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNh dGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9u cworICogYXJlIG1ldDoKKyAqCisgKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2Rl IG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiAgUmVk aXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3Ro ZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqIDMuICBOZWl0 aGVyIHRoZSBuYW1lIG9mIEFwcGxlIENvbXB1dGVyLCBJbmMuICgiQXBwbGUiKSBub3IgdGhlIG5h bWVzIG9mCisgKiAgICAgaXRzIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0byBlbmRvcnNlIG9y IHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZAorICogICAgIGZyb20gdGhpcyBzb2Z0d2FyZSB3aXRo b3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRX QVJFIElTIFBST1ZJREVEIEJZIEFQUExFIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJUyIgQU5E IEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJ VFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElTQ0xBSU1F RC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUg Rk9SIEFOWQorICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBM QVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKKyAq IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04p IEhPV0VWRVIgQ0FVU0VEIEFORAorICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRI RVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcg TkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVT RSBPRgorICogVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElU WSBPRiBTVUNIIERBTUFHRS4KKyAqLworCittb2R1bGUgd2ViYXVkaW8geworICAgIGludGVyZmFj ZSBbCisgICAgICAgIENvbmRpdGlvbmFsPVdFQl9BVURJTworICAgIF0gQXVkaW9QYXJhbSB7Cisg ICAgICAgIGF0dHJpYnV0ZSBmbG9hdCB2YWx1ZTsKKyAgICAgICAgcmVhZG9ubHkgYXR0cmlidXRl IGZsb2F0IG1pblZhbHVlOworICAgICAgICByZWFkb25seSBhdHRyaWJ1dGUgZmxvYXQgbWF4VmFs dWU7CisgICAgICAgIHJlYWRvbmx5IGF0dHJpYnV0ZSBmbG9hdCBkZWZhdWx0VmFsdWU7CisgICAg ICAgIAorICAgICAgICByZWFkb25seSBhdHRyaWJ1dGUgRE9NU3RyaW5nIG5hbWU7CisKKyAgICAg ICAgLy8gRklYTUU6IENvdWxkIGRlZmluZSB1bml0cyBjb25zdGFudHMgaGVyZSAoc2Vjb25kcywg ZGVjaWJlbHMsIGNlbnRzLCBldGMuKS4uLgorICAgICAgICByZWFkb25seSBhdHRyaWJ1dGUgdW5z aWduZWQgc2hvcnQgdW5pdHM7CisgICAgfTsKK30K