150807 2015-11-02 10:34:43 -0800 [GStreamer] Use RunLoop::Timer instead of GMainLoopSource in video sink 2015-11-05 23:29:03 -0800 1 1 1 Unclassified WebKit Platform WebKit Local Build Unspecified Unspecified RESOLVED FIXED Gtk P2 Normal --- 1 cgarcia webkit-unassigned pnormand zan oldest_to_newest 1138608 0 cgarcia 2015-11-02 10:34:43 -0800 We could use RunLoop::Timer here, since we always wait until the smaple is actually rendered we don't really need either a thread safe main loop source, nor cancelling if already requested and other things GMainLoopSource does. 1138611 1 264600 cgarcia 2015-11-02 10:38:30 -0800 Created attachment 264600 Patch 1138854 2 264600 darin 2015-11-02 22:30:23 -0800 Comment on attachment 264600 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=264600&action=review > Source/WebCore/ChangeLog:8 > + Since we always wait until the smaple is actually rendered we sample is misspelled here > Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp:78 > + // Use a higher priority than WebCore timers (G_PRIORITY_HIGH_IDLE + 20). > + m_timer.setPriority(G_PRIORITY_HIGH_IDLE + 19); This code is compiled for EFL, too. But this code is glib-specific. Is that OK for that port? Compile failed. > Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp:140 > +struct _WebKitVideoSinkPrivate { This peculiar use of a leading underscore followed by a capital letter trespasses on namespace that is reserved for compiler implementation, I believe. 1138861 3 cgarcia 2015-11-02 23:23:18 -0800 (In reply to comment #2) > Comment on attachment 264600 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=264600&action=review > > > Source/WebCore/ChangeLog:8 > > + Since we always wait until the smaple is actually rendered we > > sample is misspelled here Oops. I'll fix it. > > Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp:78 > > + // Use a higher priority than WebCore timers (G_PRIORITY_HIGH_IDLE + 20). > > + m_timer.setPriority(G_PRIORITY_HIGH_IDLE + 19); > > This code is compiled for EFL, too. But this code is glib-specific. Is that > OK for that port? Compile failed. Yes, I forgot to add platform ifdef there. > > Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp:140 > > +struct _WebKitVideoSinkPrivate { > > This peculiar use of a leading underscore followed by a capital letter > trespasses on namespace that is reserved for compiler implementation, I > believe. This is the normal way to declare the structs in GObject. They are forward declared as typedef struct _Foo Foo; and then struct _Foo { } 1138865 4 264600 zan 2015-11-03 00:43:58 -0800 Comment on attachment 264600 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=264600&action=review > Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp:90 > + m_timer.stop(); > + LockHolder locker(m_sampleMutex); Any reason behind this ordering? The m_timer is being operated on under a lock in requestRender(). > Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp:145 > + if (currentCaps) > + gst_caps_unref(currentCaps); Why is this being dereferenced in the constructor? 1138870 5 cgarcia 2015-11-03 01:22:44 -0800 (In reply to comment #4) > Comment on attachment 264600 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=264600&action=review > > > Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp:90 > > + m_timer.stop(); > > + LockHolder locker(m_sampleMutex); > > Any reason behind this ordering? The m_timer is being operated on under a > lock in requestRender(). Tried to follow what previous code did. We don't need the lock to protect the timer I think > > Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp:145 > > + if (currentCaps) > > + gst_caps_unref(currentCaps); > > Why is this being dereferenced in the constructor? Oh, good catch, that was supposed to be in the destructor :-P 1138894 6 264681 cgarcia 2015-11-03 02:49:31 -0800 Created attachment 264681 Updated patch 1139255 7 264681 zan 2015-11-03 22:36:33 -0800 Comment on attachment 264681 Updated patch View in context: https://bugs.webkit.org/attachment.cgi?id=264681&action=review > Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp:92 > + m_timer.stop(); > + LockHolder locker(m_sampleMutex); I'm still stuck on this. in requestRender() m_timer operation is protected, here it's not. Regarding previous behavior, timeoutSource was never cancelled after scheduling, except when WebKitVideoSinkPrivate was destroyed. This technically deviates from that. 1139259 8 cgarcia 2015-11-03 22:55:50 -0800 (In reply to comment #7) > Comment on attachment 264681 [details] > Updated patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=264681&action=review > > > Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp:92 > > + m_timer.stop(); > > + LockHolder locker(m_sampleMutex); > > I'm still stuck on this. in requestRender() m_timer operation is protected, > here it's not. It's not actually the timer what is protected, but the sample, we need to hold the lock for the condition wait. > Regarding previous behavior, timeoutSource was never cancelled after > scheduling, except when WebKitVideoSinkPrivate was destroyed. This > technically deviates from that. That's right, but I think it was not desirable. We always wait until the timer is actually fired. That means that if unlockSampleMutex() was called for whatever reason before the timer is fired, the sample is destroyed and the condition was released, so we don't keep waiting anymore. But the timer will be fired anyway, but will return early because sample is NULL (and unlocked = true). Stopping the timer we just avoid the callback to be called just to return. 1139263 9 264681 zan 2015-11-03 23:01:08 -0800 Comment on attachment 264681 Updated patch View in context: https://bugs.webkit.org/attachment.cgi?id=264681&action=review >>> Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp:92 >>> + LockHolder locker(m_sampleMutex); >> >> I'm still stuck on this. in requestRender() m_timer operation is protected, here it's not. >> >> Regarding previous behavior, timeoutSource was never cancelled after scheduling, except when WebKitVideoSinkPrivate was destroyed. This technically deviates from that. > > It's not actually the timer what is protected, but the sample, we need to hold the lock for the condition wait. The timer is protected in requestRender(), and I don't see any reason why it wouldn't be protected here. 1139268 10 cgarcia 2015-11-03 23:05:58 -0800 (In reply to comment #9) > Comment on attachment 264681 [details] > Updated patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=264681&action=review > > >>> Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp:92 > >>> + LockHolder locker(m_sampleMutex); > >> > >> I'm still stuck on this. in requestRender() m_timer operation is protected, here it's not. > >> > >> Regarding previous behavior, timeoutSource was never cancelled after scheduling, except when WebKitVideoSinkPrivate was destroyed. This technically deviates from that. > > > > It's not actually the timer what is protected, but the sample, we need to hold the lock for the condition wait. > > The timer is protected in requestRender(), and I don't see any reason why it > wouldn't be protected here. It's protected only because it needs to happen between changing the sample and the condition wait. In stop() we can simply cancel the timer before waiting to acquire the lock. I can move it inside the protection if you think it's a problem 1139271 11 264681 zan 2015-11-03 23:25:54 -0800 Comment on attachment 264681 Updated patch View in context: https://bugs.webkit.org/attachment.cgi?id=264681&action=review > Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp:180 > static GstFlowReturn webkitVideoSinkRender(GstBaseSink* baseSink, GstBuffer* buffer) > { > WebKitVideoSink* sink = WEBKIT_VIDEO_SINK(baseSink); > WebKitVideoSinkPrivate* priv = sink->priv; > - > - WTF::GMutexLocker<GMutex> lock(priv->sampleMutex); > - > - if (priv->unlocked) > + if (priv->scheduler.isUnlocked()) > return GST_FLOW_OK; This is another problem. Before, the sampleMutex was locked throughout this function. Now it's only locked when querying the unlocked status of the scheduler, and when requesting the render callback. So this now requires two locks per webkitVideoSinkRender() invocation, and it also allows for the scheduler state to change during these locks. I would expose a `LockHolder lock();` on the VideoRenderRequestScheduler interface, and the have the public methods accept LockHolder& as their first parameter. That way the caller is in complete control of the scope of the lock. (Inspired by bmalloc: http://trac.webkit.org/browser/trunk/Source/bmalloc/bmalloc/Heap.h#L57) 1139278 12 cgarcia 2015-11-04 00:05:18 -0800 (In reply to comment #11) > Comment on attachment 264681 [details] > Updated patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=264681&action=review > > > Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp:180 > > static GstFlowReturn webkitVideoSinkRender(GstBaseSink* baseSink, GstBuffer* buffer) > > { > > WebKitVideoSink* sink = WEBKIT_VIDEO_SINK(baseSink); > > WebKitVideoSinkPrivate* priv = sink->priv; > > - > > - WTF::GMutexLocker<GMutex> lock(priv->sampleMutex); > > - > > - if (priv->unlocked) > > + if (priv->scheduler.isUnlocked()) > > return GST_FLOW_OK; > > This is another problem. > > Before, the sampleMutex was locked throughout this function. Now it's only > locked when querying the unlocked status of the scheduler, and when > requesting the render callback. So this now requires two locks per > webkitVideoSinkRender() invocation, and it also allows for the scheduler > state to change during these locks. > > I would expose a `LockHolder lock();` on the VideoRenderRequestScheduler > interface, and the have the public methods accept LockHolder& as their first > parameter. That way the caller is in complete control of the scope of the > lock. > (Inspired by bmalloc: > http://trac.webkit.org/browser/trunk/Source/bmalloc/bmalloc/Heap.h#L57) hmm, the mutex is supposed to protect the sample and unlocked, and non of those change between the isUnlocked and requestRender in that function. However, you are right that the scheduler state could change. Wouldn't it be better to takes that into account instead and return early from requestRender if sample is NULL? In the case stop() is called before requestRender(), if we have the lock, the timer will start and right after we wait, the scheduler will stop. If we don't have the lock, we don't even start the timer. 1139279 13 cgarcia 2015-11-04 00:07:20 -0800 (In reply to comment #12) > (In reply to comment #11) > > Comment on attachment 264681 [details] > > Updated patch > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=264681&action=review > > > > > Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp:180 > > > static GstFlowReturn webkitVideoSinkRender(GstBaseSink* baseSink, GstBuffer* buffer) > > > { > > > WebKitVideoSink* sink = WEBKIT_VIDEO_SINK(baseSink); > > > WebKitVideoSinkPrivate* priv = sink->priv; > > > - > > > - WTF::GMutexLocker<GMutex> lock(priv->sampleMutex); > > > - > > > - if (priv->unlocked) > > > + if (priv->scheduler.isUnlocked()) > > > return GST_FLOW_OK; > > > > This is another problem. > > > > Before, the sampleMutex was locked throughout this function. Now it's only > > locked when querying the unlocked status of the scheduler, and when > > requesting the render callback. So this now requires two locks per > > webkitVideoSinkRender() invocation, and it also allows for the scheduler > > state to change during these locks. > > > > I would expose a `LockHolder lock();` on the VideoRenderRequestScheduler > > interface, and the have the public methods accept LockHolder& as their first > > parameter. That way the caller is in complete control of the scope of the > > lock. > > (Inspired by bmalloc: > > http://trac.webkit.org/browser/trunk/Source/bmalloc/bmalloc/Heap.h#L57) > > hmm, the mutex is supposed to protect the sample and unlocked, and non of > those change between the isUnlocked and requestRender in that function. > However, you are right that the scheduler state could change. Wouldn't it be > better to takes that into account instead and return early from > requestRender if sample is NULL? We should actually check if m_unlocked is true, instead. > In the case stop() is called before > requestRender(), if we have the lock, the timer will start and right after > we wait, the scheduler will stop. If we don't have the lock, we don't even > start the timer. 1139286 14 264681 zan 2015-11-04 00:30:51 -0800 Comment on attachment 264681 Updated patch View in context: https://bugs.webkit.org/attachment.cgi?id=264681&action=review >>>> Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp:180 >>>> return GST_FLOW_OK; >>> >>> This is another problem. >>> >>> Before, the sampleMutex was locked throughout this function. Now it's only locked when querying the unlocked status of the scheduler, and when requesting the render callback. So this now requires two locks per webkitVideoSinkRender() invocation, and it also allows for the scheduler state to change during these locks. >>> >>> I would expose a `LockHolder lock();` on the VideoRenderRequestScheduler interface, and the have the public methods accept LockHolder& as their first parameter. That way the caller is in complete control of the scope of the lock. >>> (Inspired by bmalloc: http://trac.webkit.org/browser/trunk/Source/bmalloc/bmalloc/Heap.h#L57) >> >> hmm, the mutex is supposed to protect the sample and unlocked, and non of those change between the isUnlocked and requestRender in that function. However, you are right that the scheduler state could change. Wouldn't it be better to takes that into account instead and return early from requestRender if sample is NULL? In the case stop() is called before requestRender(), if we have the lock, the timer will start and right after we wait, the scheduler will stop. If we don't have the lock, we don't even start the timer. > > We should actually check if m_unlocked is true, instead. The sample and unlock don't change during this function, or rather they're not changed directly by us. It's still entirely possible for some other thread to acquire the lock during this function call. All in all, having the lock out of control during this function now definitely changes behavior. I'm not fine with that. 1139287 15 cgarcia 2015-11-04 00:35:07 -0800 (In reply to comment #14) > Comment on attachment 264681 [details] > Updated patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=264681&action=review > > >>>> Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp:180 > >>>> return GST_FLOW_OK; > >>> > >>> This is another problem. > >>> > >>> Before, the sampleMutex was locked throughout this function. Now it's only locked when querying the unlocked status of the scheduler, and when requesting the render callback. So this now requires two locks per webkitVideoSinkRender() invocation, and it also allows for the scheduler state to change during these locks. > >>> > >>> I would expose a `LockHolder lock();` on the VideoRenderRequestScheduler interface, and the have the public methods accept LockHolder& as their first parameter. That way the caller is in complete control of the scope of the lock. > >>> (Inspired by bmalloc: http://trac.webkit.org/browser/trunk/Source/bmalloc/bmalloc/Heap.h#L57) > >> > >> hmm, the mutex is supposed to protect the sample and unlocked, and non of those change between the isUnlocked and requestRender in that function. However, you are right that the scheduler state could change. Wouldn't it be better to takes that into account instead and return early from requestRender if sample is NULL? In the case stop() is called before requestRender(), if we have the lock, the timer will start and right after we wait, the scheduler will stop. If we don't have the lock, we don't even start the timer. > > > > We should actually check if m_unlocked is true, instead. > > The sample and unlock don't change during this function, or rather they're > not changed directly by us. It's still entirely possible for some other > thread to acquire the lock during this function call. Yes, that's whay I think we can handle that case by simply returning early from requestRender() if the state changed by another thread. > All in all, having the lock out of control during this function now > definitely changes behavior. I'm not fine with that. Ok, I agree this is probably out of scope of this bug that is supposed to be only a refactoring. 1139303 16 264784 cgarcia 2015-11-04 02:39:38 -0800 Created attachment 264784 Updated patch Ensure the lock is held while request rendering 1139557 17 264784 zan 2015-11-04 23:00:04 -0800 Comment on attachment 264784 Updated patch Looks OK, I'll leave it to Phil to r+. 1139560 18 264784 pnormand 2015-11-05 00:06:30 -0800 Comment on attachment 264784 Updated patch View in context: https://bugs.webkit.org/attachment.cgi?id=264784&action=review > Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp:78 > +#if PLATFORM(GTK) USE(GLIB) && !PLATFORM(EFL) please :) 1139561 19 264784 zan 2015-11-05 00:06:53 -0800 Comment on attachment 264784 Updated patch r=me if Phil doesn't object. 1139893 20 cgarcia 2015-11-05 23:04:37 -0800 (In reply to comment #18) > Comment on attachment 264784 [details] > Updated patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=264784&action=review > > > Source/WebCore/platform/graphics/gstreamer/VideoSinkGStreamer.cpp:78 > > +#if PLATFORM(GTK) > > USE(GLIB) && !PLATFORM(EFL) please :) I don't think this is correct in this particular case. It's true that setPriority is defined that way in WTF, but here there's also the priority set that only makes sense in GTK+, because of the MainThreadSharedTimerGtk implementation and the priorities used by GTK+ itself. This behaviour is very GTK+ specific 1139898 21 cgarcia 2015-11-05 23:29:03 -0800 Committed r192094: <http://trac.webkit.org/changeset/192094> 264600 2015-11-02 10:38:30 -0800 2015-11-03 02:49:31 -0800 Patch wcore-gst-video-sink-timer.diff text/plain 10517 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCBlODk3NGYzLi41ODQ3NDlhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsMzcg QEAKIDIwMTUtMTEtMDIgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29t PgogCisgICAgICAgIFtHU3RyZWFtZXJdIFVzZSBSdW5Mb29wOjpUaW1lciBpbnN0ZWFkIG9mIEdN YWluTG9vcFNvdXJjZSBpbiB2aWRlbyBzaW5rCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xNTA4MDcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBTaW5jZSB3ZSBhbHdheXMgd2FpdCB1bnRpbCB0aGUgc21hcGxl IGlzIGFjdHVhbGx5IHJlbmRlcmVkIHdlCisgICAgICAgIGRvbid0IHJlYWxseSBuZWVkIGVpdGhl ciBhIHRocmVhZCBzYWZlIG1haW4gbG9vcCBzb3VyY2UsIG5vcgorICAgICAgICBjYW5jZWxsaW5n IGlmIGFscmVhZHkgcmVxdWVzdGVkIGFuZCBvdGhlciB0aGluZ3MgR01haW5Mb29wU291cmNlIGRv ZXMuCisgICAgICAgIFRoaXMgYWRkcyBhIGhlbHBlciBjbGFzcyBWaWRlb1JlbmRlclJlcXVlc3RT Y2hlZHVsZXIgdG8gdXNlIHRoZQorICAgICAgICBSdW5Mb29wOjpUaW1lci4gQWxsIHRoZSBsb2dp YyB0byBzeW5jcm9uaXplIGJldHdlZW4gdGhyZWFkcyBoYXMKKyAgICAgICAgYmVlbiBtb3ZlZCB0 byB0aGlzIGhlbHBlciBjbGFzcyB0b28uCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9n c3RyZWFtZXIvVmlkZW9TaW5rR1N0cmVhbWVyLmNwcDoKKyAgICAgICAgKFZpZGVvUmVuZGVyUmVx dWVzdFNjaGVkdWxlcjo6VmlkZW9SZW5kZXJSZXF1ZXN0U2NoZWR1bGVyKToKKyAgICAgICAgKFZp ZGVvUmVuZGVyUmVxdWVzdFNjaGVkdWxlcjo6c3RhcnQpOgorICAgICAgICAoVmlkZW9SZW5kZXJS ZXF1ZXN0U2NoZWR1bGVyOjpzdG9wKToKKyAgICAgICAgKFZpZGVvUmVuZGVyUmVxdWVzdFNjaGVk dWxlcjo6cmVxdWVzdFJlbmRlcik6CisgICAgICAgIChWaWRlb1JlbmRlclJlcXVlc3RTY2hlZHVs ZXI6OmlzVW5sb2NrZWQpOgorICAgICAgICAoVmlkZW9SZW5kZXJSZXF1ZXN0U2NoZWR1bGVyOjpy ZW5kZXIpOgorICAgICAgICAoX1dlYktpdFZpZGVvU2lua1ByaXZhdGU6Ol9XZWJLaXRWaWRlb1Np bmtQcml2YXRlKToKKyAgICAgICAgKHdlYmtpdFZpZGVvU2lua1JlcGFpbnRSZXF1ZXN0ZWQpOgor ICAgICAgICAod2Via2l0VmlkZW9TaW5rUmVuZGVyKToKKyAgICAgICAgKHdlYmtpdFZpZGVvU2lu a1VubG9jayk6CisgICAgICAgICh3ZWJraXRWaWRlb1NpbmtVbmxvY2tTdG9wKToKKyAgICAgICAg KHdlYmtpdFZpZGVvU2lua1N0b3ApOgorICAgICAgICAod2Via2l0VmlkZW9TaW5rU3RhcnQpOgor ICAgICAgICAoX1dlYktpdFZpZGVvU2lua1ByaXZhdGU6On5fV2ViS2l0VmlkZW9TaW5rUHJpdmF0 ZSk6IERlbGV0ZWQuCisgICAgICAgICh3ZWJraXRWaWRlb1NpbmtUaW1lb3V0Q2FsbGJhY2spOiBE ZWxldGVkLgorICAgICAgICAodW5sb2NrU2FtcGxlTXV0ZXgpOiBEZWxldGVkLgorCisyMDE1LTEx LTAyICBDYXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4KKwogICAgICAg ICBbR1N0cmVhbWVyXSBDbGVhbnVwIHRoZSBpcmFkaW8gcHJvcGVydGllcwogICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ4NTIyCiAKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9WaWRlb1NpbmtHU3Ry ZWFtZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL1Zp ZGVvU2lua0dTdHJlYW1lci5jcHAKaW5kZXggZGZkMjQ1OC4uNGFiZjRmNiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL1ZpZGVvU2lua0dTdHJl YW1lci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVy L1ZpZGVvU2lua0dTdHJlYW1lci5jcHAKQEAgLTM1LDggKzM1LDggQEAKICNpbmNsdWRlIDxnbGli Lmg+CiAjaW5jbHVkZSA8Z3N0L2dzdC5oPgogI2luY2x1ZGUgPGdzdC92aWRlby9nc3R2aWRlb21l dGEuaD4KLSNpbmNsdWRlIDx3dGYvZ2xpYi9HTXV0ZXhMb2NrZXIuaD4KLSNpbmNsdWRlIDx3dGYv Z2xpYi9HVGhyZWFkU2FmZU1haW5Mb29wU291cmNlLmg+CisjaW5jbHVkZSA8d3RmL0NvbmRpdGlv bi5oPgorI2luY2x1ZGUgPHd0Zi9SdW5Mb29wLmg+CiAKIHVzaW5nIG5hbWVzcGFjZSBXZWJDb3Jl OwogCkBAIC02NywzOCArNjcsODcgQEAgZW51bSB7CiAKIHN0YXRpYyBndWludCB3ZWJraXRWaWRl b1NpbmtTaWduYWxzW0xBU1RfU0lHTkFMXSA9IHsgMCwgfTsKIAotc3RydWN0IF9XZWJLaXRWaWRl b1NpbmtQcml2YXRlIHsKLSAgICBfV2ViS2l0VmlkZW9TaW5rUHJpdmF0ZSgpCitzdGF0aWMgdm9p ZCB3ZWJraXRWaWRlb1NpbmtSZXBhaW50UmVxdWVzdGVkKFdlYktpdFZpZGVvU2luayosIEdzdFNh bXBsZSopOworCitjbGFzcyBWaWRlb1JlbmRlclJlcXVlc3RTY2hlZHVsZXIgeworcHVibGljOgor ICAgIFZpZGVvUmVuZGVyUmVxdWVzdFNjaGVkdWxlcigpCisgICAgICAgIDogbV90aW1lcihSdW5M b29wOjptYWluKCksIHRoaXMsICZWaWRlb1JlbmRlclJlcXVlc3RTY2hlZHVsZXI6OnJlbmRlcikK ICAgICB7Ci0gICAgICAgIGdfbXV0ZXhfaW5pdCgmc2FtcGxlTXV0ZXgpOwotICAgICAgICBnX2Nv bmRfaW5pdCgmZGF0YUNvbmRpdGlvbik7Ci0gICAgICAgIGdzdF92aWRlb19pbmZvX2luaXQoJmlu Zm8pOworICAgICAgICAvLyBVc2UgYSBoaWdoZXIgcHJpb3JpdHkgdGhhbiBXZWJDb3JlIHRpbWVy cyAoR19QUklPUklUWV9ISUdIX0lETEUgKyAyMCkuCisgICAgICAgIG1fdGltZXIuc2V0UHJpb3Jp dHkoR19QUklPUklUWV9ISUdIX0lETEUgKyAxOSk7CiAgICAgfQogCi0gICAgfl9XZWJLaXRWaWRl b1NpbmtQcml2YXRlKCkKKyAgICB2b2lkIHN0YXJ0KCkKICAgICB7Ci0gICAgICAgIGdfbXV0ZXhf Y2xlYXIoJnNhbXBsZU11dGV4KTsKLSAgICAgICAgZ19jb25kX2NsZWFyKCZkYXRhQ29uZGl0aW9u KTsKKyAgICAgICAgTG9ja0hvbGRlciBsb2NrZXIobV9zYW1wbGVNdXRleCk7CisgICAgICAgIG1f dW5sb2NrZWQgPSBmYWxzZTsKICAgICB9CiAKLSAgICBHc3RTYW1wbGUqIHNhbXBsZTsKLSAgICBH VGhyZWFkU2FmZU1haW5Mb29wU291cmNlIHRpbWVvdXRTb3VyY2U7Ci0gICAgR011dGV4IHNhbXBs ZU11dGV4OwotICAgIEdDb25kIGRhdGFDb25kaXRpb247CisgICAgdm9pZCBzdG9wKCkKKyAgICB7 CisgICAgICAgIG1fdGltZXIuc3RvcCgpOworICAgICAgICBMb2NrSG9sZGVyIGxvY2tlcihtX3Nh bXBsZU11dGV4KTsKKyAgICAgICAgbV9zYW1wbGUgPSBudWxscHRyOworICAgICAgICBtX3VubG9j a2VkID0gdHJ1ZTsKKyAgICAgICAgbV9kYXRhQ29uZGl0aW9uLm5vdGlmeU9uZSgpOworICAgIH0K IAotICAgIEdzdFZpZGVvSW5mbyBpbmZvOworICAgIHZvaWQgcmVxdWVzdFJlbmRlcihXZWJLaXRW aWRlb1NpbmsqIHNpbmssIEdSZWZQdHI8R3N0U2FtcGxlPiYmIHNhbXBsZSkKKyAgICB7CisgICAg ICAgIExvY2tIb2xkZXIgbG9ja2VyKG1fc2FtcGxlTXV0ZXgpOworICAgICAgICBtX3NhbXBsZSA9 IFdURjo6bW92ZShzYW1wbGUpOworICAgICAgICBtX3NpbmsgPSBzaW5rOworICAgICAgICBtX3Rp bWVyLnN0YXJ0T25lU2hvdCgwKTsKKyAgICAgICAgbV9kYXRhQ29uZGl0aW9uLndhaXQobV9zYW1w bGVNdXRleCk7CisgICAgfQogCi0gICAgR3N0Q2FwcyogY3VycmVudENhcHM7CisgICAgYm9vbCBp c1VubG9ja2VkKCkKKyAgICB7CisgICAgICAgIExvY2tIb2xkZXIgbG9ja2VyKG1fc2FtcGxlTXV0 ZXgpOworICAgICAgICByZXR1cm4gbV91bmxvY2tlZDsKKyAgICB9CisKK3ByaXZhdGU6CiAKLSAg ICAvLyBJZiB0aGlzIGlzIFRSVUUgYWxsIHByb2Nlc3Npbmcgc2hvdWxkIGZpbmlzaCBBU0FQCisg ICAgdm9pZCByZW5kZXIoKQorICAgIHsKKyAgICAgICAgTG9ja0hvbGRlciBsb2NrZXIobV9zYW1w bGVNdXRleCk7CisgICAgICAgIEdSZWZQdHI8R3N0U2FtcGxlPiBzYW1wbGUgPSBXVEY6Om1vdmUo bV9zYW1wbGUpOworICAgICAgICBHUmVmUHRyPFdlYktpdFZpZGVvU2luaz4gc2luayA9IFdURjo6 bW92ZShtX3NpbmspOworICAgICAgICBpZiAoc2FtcGxlICYmICFtX3VubG9ja2VkICYmIExJS0VM WShHU1RfSVNfU0FNUExFKHNhbXBsZS5nZXQoKSkpKQorICAgICAgICAgICAgd2Via2l0VmlkZW9T aW5rUmVwYWludFJlcXVlc3RlZChzaW5rLmdldCgpLCBzYW1wbGUuZ2V0KCkpOworICAgICAgICBt X2RhdGFDb25kaXRpb24ubm90aWZ5T25lKCk7CisgICAgfQorCisgICAgUnVuTG9vcDo6VGltZXI8 VmlkZW9SZW5kZXJSZXF1ZXN0U2NoZWR1bGVyPiBtX3RpbWVyOworICAgIExvY2sgbV9zYW1wbGVN dXRleDsKKyAgICBDb25kaXRpb24gbV9kYXRhQ29uZGl0aW9uOworICAgIEdSZWZQdHI8R3N0U2Ft cGxlPiBtX3NhbXBsZTsKKyAgICBHUmVmUHRyPFdlYktpdFZpZGVvU2luaz4gbV9zaW5rOworCisg ICAgLy8gSWYgdGhpcyBpcyB0cnVlIGFsbCBwcm9jZXNzaW5nIHNob3VsZCBmaW5pc2ggQVNBUAog ICAgIC8vIFRoaXMgaXMgbmVjZXNzYXJ5IGJlY2F1c2UgdGhlcmUgY291bGQgYmUgYSByYWNlIGJl dHdlZW4KICAgICAvLyB1bmxvY2soKSBhbmQgcmVuZGVyKCksIHdoZXJlIHVubG9jaygpIHdpbnMs IHNpZ25hbHMgdGhlCi0gICAgLy8gR0NvbmQsIHRoZW4gcmVuZGVyKCkgdHJpZXMgdG8gcmVuZGVy IGEgZnJhbWUgYWx0aG91Z2gKKyAgICAvLyBDb25kaXRpb24sIHRoZW4gcmVuZGVyKCkgdHJpZXMg dG8gcmVuZGVyIGEgZnJhbWUgYWx0aG91Z2gKICAgICAvLyBldmVyeXRoaW5nIGVsc2UgaXNuJ3Qg cnVubmluZyBhbnltb3JlLiBUaGlzIHdpbGwgbGVhZAogICAgIC8vIHRvIGRlYWRsb2NrcyBiZWNh dXNlIHJlbmRlcigpIGhvbGRzIHRoZSBzdHJlYW0gbG9jay4KICAgICAvLwogICAgIC8vIFByb3Rl Y3RlZCBieSB0aGUgc2FtcGxlIG11dGV4Ci0gICAgYm9vbCB1bmxvY2tlZDsKKyAgICBib29sIG1f dW5sb2NrZWQgeyBmYWxzZSB9OworfTsKKworc3RydWN0IF9XZWJLaXRWaWRlb1NpbmtQcml2YXRl IHsKKyAgICBfV2ViS2l0VmlkZW9TaW5rUHJpdmF0ZSgpCisgICAgeworICAgICAgICBnc3Rfdmlk ZW9faW5mb19pbml0KCZpbmZvKTsKKyAgICAgICAgaWYgKGN1cnJlbnRDYXBzKQorICAgICAgICAg ICAgZ3N0X2NhcHNfdW5yZWYoY3VycmVudENhcHMpOworICAgIH0KKworICAgIFZpZGVvUmVuZGVy UmVxdWVzdFNjaGVkdWxlciBzY2hlZHVsZXI7CisgICAgR3N0VmlkZW9JbmZvIGluZm87CisgICAg R3N0Q2FwcyogY3VycmVudENhcHM7CiB9OwogCiAjZGVmaW5lIHdlYmtpdF92aWRlb19zaW5rX3Bh cmVudF9jbGFzcyBwYXJlbnRfY2xhc3MKQEAgLTExMiw0MiArMTYxLDI0IEBAIHN0YXRpYyB2b2lk IHdlYmtpdF92aWRlb19zaW5rX2luaXQoV2ViS2l0VmlkZW9TaW5rKiBzaW5rKQogICAgIG5ldyAo c2luay0+cHJpdikgV2ViS2l0VmlkZW9TaW5rUHJpdmF0ZSgpOwogfQogCi1zdGF0aWMgdm9pZCB3 ZWJraXRWaWRlb1NpbmtUaW1lb3V0Q2FsbGJhY2soV2ViS2l0VmlkZW9TaW5rKiBzaW5rKQorc3Rh dGljIHZvaWQgd2Via2l0VmlkZW9TaW5rUmVwYWludFJlcXVlc3RlZChXZWJLaXRWaWRlb1Npbmsq IHNpbmssIEdzdFNhbXBsZSogc2FtcGxlKQogewotICAgIFdlYktpdFZpZGVvU2lua1ByaXZhdGUq IHByaXYgPSBzaW5rLT5wcml2OwotCi0gICAgV1RGOjpHTXV0ZXhMb2NrZXI8R011dGV4PiBsb2Nr KHByaXYtPnNhbXBsZU11dGV4KTsKLSAgICBHc3RTYW1wbGUqIHNhbXBsZSA9IHByaXYtPnNhbXBs ZTsKLSAgICBwcml2LT5zYW1wbGUgPSAwOwotCi0gICAgaWYgKCFzYW1wbGUgfHwgcHJpdi0+dW5s b2NrZWQgfHwgVU5MSUtFTFkoIUdTVF9JU19TQU1QTEUoc2FtcGxlKSkpIHsKLSAgICAgICAgZ19j b25kX3NpZ25hbCgmcHJpdi0+ZGF0YUNvbmRpdGlvbik7Ci0gICAgICAgIHJldHVybjsKLSAgICB9 Ci0KICAgICBnX3NpZ25hbF9lbWl0KHNpbmssIHdlYmtpdFZpZGVvU2lua1NpZ25hbHNbUkVQQUlO VF9SRVFVRVNURURdLCAwLCBzYW1wbGUpOwotICAgIGdzdF9zYW1wbGVfdW5yZWYoc2FtcGxlKTsK LSAgICBnX2NvbmRfc2lnbmFsKCZwcml2LT5kYXRhQ29uZGl0aW9uKTsKIH0KIAogc3RhdGljIEdz dEZsb3dSZXR1cm4gd2Via2l0VmlkZW9TaW5rUmVuZGVyKEdzdEJhc2VTaW5rKiBiYXNlU2luaywg R3N0QnVmZmVyKiBidWZmZXIpCiB7CiAgICAgV2ViS2l0VmlkZW9TaW5rKiBzaW5rID0gV0VCS0lU X1ZJREVPX1NJTksoYmFzZVNpbmspOwogICAgIFdlYktpdFZpZGVvU2lua1ByaXZhdGUqIHByaXYg PSBzaW5rLT5wcml2OwotCi0gICAgV1RGOjpHTXV0ZXhMb2NrZXI8R011dGV4PiBsb2NrKHByaXYt PnNhbXBsZU11dGV4KTsKLQotICAgIGlmIChwcml2LT51bmxvY2tlZCkKKyAgICBpZiAocHJpdi0+ c2NoZWR1bGVyLmlzVW5sb2NrZWQoKSkKICAgICAgICAgcmV0dXJuIEdTVF9GTE9XX09LOwogCi0g ICAgcHJpdi0+c2FtcGxlID0gZ3N0X3NhbXBsZV9uZXcoYnVmZmVyLCBwcml2LT5jdXJyZW50Q2Fw cywgMCwgMCk7CisgICAgR1JlZlB0cjxHc3RTYW1wbGU+IHNhbXBsZSA9IGFkb3B0R1JlZihnc3Rf c2FtcGxlX25ldyhidWZmZXIsIHByaXYtPmN1cnJlbnRDYXBzLCBudWxscHRyLCBudWxscHRyKSk7 CiAKICAgICAvLyBUaGUgdmlkZW8gaW5mbyBzdHJ1Y3R1cmUgaXMgdmFsaWQgb25seSBpZiB0aGUg c2luayBoYW5kbGVkIGFuIGFsbG9jYXRpb24gcXVlcnkuCiAgICAgR3N0VmlkZW9Gb3JtYXQgZm9y bWF0ID0gR1NUX1ZJREVPX0lORk9fRk9STUFUKCZwcml2LT5pbmZvKTsKLSAgICBpZiAoZm9ybWF0 ID09IEdTVF9WSURFT19GT1JNQVRfVU5LTk9XTikgewotICAgICAgICBnc3Rfc2FtcGxlX3VucmVm KHByaXYtPnNhbXBsZSk7CisgICAgaWYgKGZvcm1hdCA9PSBHU1RfVklERU9fRk9STUFUX1VOS05P V04pCiAgICAgICAgIHJldHVybiBHU1RfRkxPV19FUlJPUjsKLSAgICB9CiAKICNpZiAhKFVTRShU RVhUVVJFX01BUFBFUl9HTCkgJiYgIVVTRShDT09SRElOQVRFRF9HUkFQSElDUykpCiAgICAgLy8g Q2Fpcm8ncyBBUkdCIGhhcyBwcmUtbXVsdGlwbGllZCBhbHBoYSB3aGlsZSBHU3RyZWFtZXIncyBk b2Vzbid0LgpAQCAtMTc0LDcgKzIwNSw2IEBAIHN0YXRpYyBHc3RGbG93UmV0dXJuIHdlYmtpdFZp ZGVvU2lua1JlbmRlcihHc3RCYXNlU2luayogYmFzZVNpbmssIEdzdEJ1ZmZlciogYnVmCiAgICAg ICAgIEdzdFZpZGVvRnJhbWUgZGVzdGluYXRpb25GcmFtZTsKIAogICAgICAgICBpZiAoIWdzdF92 aWRlb19mcmFtZV9tYXAoJnNvdXJjZUZyYW1lLCAmcHJpdi0+aW5mbywgYnVmZmVyLCBHU1RfTUFQ X1JFQUQpKSB7Ci0gICAgICAgICAgICBnc3Rfc2FtcGxlX3VucmVmKHByaXYtPnNhbXBsZSk7CiAg ICAgICAgICAgICBnc3RfYnVmZmVyX3VucmVmKG5ld0J1ZmZlcik7CiAgICAgICAgICAgICByZXR1 cm4gR1NUX0ZMT1dfRVJST1I7CiAgICAgICAgIH0KQEAgLTIwOSwxOSArMjM5LDExIEBAIHN0YXRp YyBHc3RGbG93UmV0dXJuIHdlYmtpdFZpZGVvU2lua1JlbmRlcihHc3RCYXNlU2luayogYmFzZVNp bmssIEdzdEJ1ZmZlciogYnVmCiAKICAgICAgICAgZ3N0X3ZpZGVvX2ZyYW1lX3VubWFwKCZzb3Vy Y2VGcmFtZSk7CiAgICAgICAgIGdzdF92aWRlb19mcmFtZV91bm1hcCgmZGVzdGluYXRpb25GcmFt ZSk7Ci0gICAgICAgIGdzdF9zYW1wbGVfdW5yZWYocHJpdi0+c2FtcGxlKTsKLSAgICAgICAgcHJp di0+c2FtcGxlID0gZ3N0X3NhbXBsZV9uZXcobmV3QnVmZmVyLCBwcml2LT5jdXJyZW50Q2Fwcywg MCwgMCk7CisgICAgICAgIHNhbXBsZSA9IGFkb3B0R1JlZihnc3Rfc2FtcGxlX25ldyhuZXdCdWZm ZXIsIHByaXYtPmN1cnJlbnRDYXBzLCBudWxscHRyLCBudWxscHRyKSk7CiAgICAgfQogI2VuZGlm CiAKLSAgICAvLyBUaGlzIHNob3VsZCBsaWtlbHkgdXNlIGEgbG93ZXIgcHJpb3JpdHksIGJ1dCBn bGliIGN1cnJlbnRseSBzdGFydmVzCi0gICAgLy8gbG93ZXIgcHJpb3JpdHkgc291cmNlcy4KLSAg ICAvLyBTZWU6IGh0dHBzOi8vYnVnemlsbGEuZ25vbWUub3JnL3Nob3dfYnVnLmNnaT9pZD02MTA4 MzAuCi0gICAgR1JlZlB0cjxXZWJLaXRWaWRlb1Npbms+IHByb3RlY3RvcihzaW5rKTsKLSAgICBw cml2LT50aW1lb3V0U291cmNlLnNjaGVkdWxlKCJbV2ViS2l0XSB3ZWJraXRWaWRlb1NpbmtUaW1l b3V0Q2FsbGJhY2siLAotICAgICAgICBzdGQ6OmZ1bmN0aW9uPHZvaWQoKT4oW3Byb3RlY3Rvcl0g eyB3ZWJraXRWaWRlb1NpbmtUaW1lb3V0Q2FsbGJhY2socHJvdGVjdG9yLmdldCgpKTsgfSkpOwot Ci0gICAgZ19jb25kX3dhaXQoJnByaXYtPmRhdGFDb25kaXRpb24sICZwcml2LT5zYW1wbGVNdXRl eCk7CisgICAgcHJpdi0+c2NoZWR1bGVyLnJlcXVlc3RSZW5kZXIoc2luaywgV1RGOjptb3ZlKHNh bXBsZSkpOwogICAgIHJldHVybiBHU1RfRkxPV19PSzsKIH0KIApAQCAtMjMxLDI1ICsyNTMsMTEg QEAgc3RhdGljIHZvaWQgd2Via2l0VmlkZW9TaW5rRmluYWxpemUoR09iamVjdCogb2JqZWN0KQog ICAgIEdfT0JKRUNUX0NMQVNTKHBhcmVudF9jbGFzcyktPmZpbmFsaXplKG9iamVjdCk7CiB9CiAK LXN0YXRpYyB2b2lkIHVubG9ja1NhbXBsZU11dGV4KFdlYktpdFZpZGVvU2lua1ByaXZhdGUqIHBy aXYpCi17Ci0gICAgV1RGOjpHTXV0ZXhMb2NrZXI8R011dGV4PiBsb2NrKHByaXYtPnNhbXBsZU11 dGV4KTsKLQotICAgIGlmIChwcml2LT5zYW1wbGUpIHsKLSAgICAgICAgZ3N0X3NhbXBsZV91bnJl Zihwcml2LT5zYW1wbGUpOwotICAgICAgICBwcml2LT5zYW1wbGUgPSAwOwotICAgIH0KLQotICAg IHByaXYtPnVubG9ja2VkID0gdHJ1ZTsKLQotICAgIGdfY29uZF9zaWduYWwoJnByaXYtPmRhdGFD b25kaXRpb24pOwotfQotCiBzdGF0aWMgZ2Jvb2xlYW4gd2Via2l0VmlkZW9TaW5rVW5sb2NrKEdz dEJhc2VTaW5rKiBiYXNlU2luaykKIHsKLSAgICBXZWJLaXRWaWRlb1NpbmsqIHNpbmsgPSBXRUJL SVRfVklERU9fU0lOSyhiYXNlU2luayk7CisgICAgV2ViS2l0VmlkZW9TaW5rUHJpdmF0ZSogcHJp diA9IFdFQktJVF9WSURFT19TSU5LKGJhc2VTaW5rKS0+cHJpdjsKIAotICAgIHVubG9ja1NhbXBs ZU11dGV4KHNpbmstPnByaXYpOworICAgIHByaXYtPnNjaGVkdWxlci5zdG9wKCk7CiAKICAgICBy ZXR1cm4gR1NUX0NBTExfUEFSRU5UX1dJVEhfREVGQVVMVChHU1RfQkFTRV9TSU5LX0NMQVNTLCB1 bmxvY2ssIChiYXNlU2luayksIFRSVUUpOwogfQpAQCAtMjU4LDEwICsyNjYsNyBAQCBzdGF0aWMg Z2Jvb2xlYW4gd2Via2l0VmlkZW9TaW5rVW5sb2NrU3RvcChHc3RCYXNlU2luayogYmFzZVNpbmsp CiB7CiAgICAgV2ViS2l0VmlkZW9TaW5rUHJpdmF0ZSogcHJpdiA9IFdFQktJVF9WSURFT19TSU5L KGJhc2VTaW5rKS0+cHJpdjsKIAotICAgIHsKLSAgICAgICAgV1RGOjpHTXV0ZXhMb2NrZXI8R011 dGV4PiBsb2NrKHByaXYtPnNhbXBsZU11dGV4KTsKLSAgICAgICAgcHJpdi0+dW5sb2NrZWQgPSBm YWxzZTsKLSAgICB9CisgICAgcHJpdi0+c2NoZWR1bGVyLnN0YXJ0KCk7CiAKICAgICByZXR1cm4g R1NUX0NBTExfUEFSRU5UX1dJVEhfREVGQVVMVChHU1RfQkFTRV9TSU5LX0NMQVNTLCB1bmxvY2tf c3RvcCwgKGJhc2VTaW5rKSwgVFJVRSk7CiB9CkBAIC0yNzAsMTEgKzI3NSwxMCBAQCBzdGF0aWMg Z2Jvb2xlYW4gd2Via2l0VmlkZW9TaW5rU3RvcChHc3RCYXNlU2luayogYmFzZVNpbmspCiB7CiAg ICAgV2ViS2l0VmlkZW9TaW5rUHJpdmF0ZSogcHJpdiA9IFdFQktJVF9WSURFT19TSU5LKGJhc2VT aW5rKS0+cHJpdjsKIAotICAgIHVubG9ja1NhbXBsZU11dGV4KHByaXYpOwotCisgICAgcHJpdi0+ c2NoZWR1bGVyLnN0b3AoKTsKICAgICBpZiAocHJpdi0+Y3VycmVudENhcHMpIHsKICAgICAgICAg Z3N0X2NhcHNfdW5yZWYocHJpdi0+Y3VycmVudENhcHMpOwotICAgICAgICBwcml2LT5jdXJyZW50 Q2FwcyA9IDA7CisgICAgICAgIHByaXYtPmN1cnJlbnRDYXBzID0gbnVsbHB0cjsKICAgICB9CiAK ICAgICByZXR1cm4gVFJVRTsKQEAgLTI4NCw4ICsyODgsOCBAQCBzdGF0aWMgZ2Jvb2xlYW4gd2Vi a2l0VmlkZW9TaW5rU3RhcnQoR3N0QmFzZVNpbmsqIGJhc2VTaW5rKQogewogICAgIFdlYktpdFZp ZGVvU2lua1ByaXZhdGUqIHByaXYgPSBXRUJLSVRfVklERU9fU0lOSyhiYXNlU2luayktPnByaXY7 CiAKLSAgICBXVEY6OkdNdXRleExvY2tlcjxHTXV0ZXg+IGxvY2socHJpdi0+c2FtcGxlTXV0ZXgp OwotICAgIHByaXYtPnVubG9ja2VkID0gZmFsc2U7CisgICAgcHJpdi0+c2NoZWR1bGVyLnN0YXJ0 KCk7CisKICAgICByZXR1cm4gVFJVRTsKIH0KIAo= 264681 2015-11-03 02:49:31 -0800 2015-11-04 02:39:38 -0800 Updated patch wcore-gst-video-sink-timer.diff text/plain 10655 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA2OWUwOWNhLi5hMDE1NGQ2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsMzcg QEAKIDIwMTUtMTEtMDMgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29t PgogCisgICAgICAgIFtHU3RyZWFtZXJdIFVzZSBSdW5Mb29wOjpUaW1lciBpbnN0ZWFkIG9mIEdN YWluTG9vcFNvdXJjZSBpbiB2aWRlbyBzaW5rCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xNTA4MDcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBTaW5jZSB3ZSBhbHdheXMgd2FpdCB1bnRpbCB0aGUgc2FtcGxl IGlzIGFjdHVhbGx5IHJlbmRlcmVkIHdlCisgICAgICAgIGRvbid0IHJlYWxseSBuZWVkIGVpdGhl ciBhIHRocmVhZCBzYWZlIG1haW4gbG9vcCBzb3VyY2UsIG5vcgorICAgICAgICBjYW5jZWxsaW5n IGlmIGFscmVhZHkgcmVxdWVzdGVkIGFuZCBvdGhlciB0aGluZ3MgR01haW5Mb29wU291cmNlIGRv ZXMuCisgICAgICAgIFRoaXMgYWRkcyBhIGhlbHBlciBjbGFzcyBWaWRlb1JlbmRlclJlcXVlc3RT Y2hlZHVsZXIgdG8gdXNlIHRoZQorICAgICAgICBSdW5Mb29wOjpUaW1lci4gQWxsIHRoZSBsb2dp YyB0byBzeW5jcm9uaXplIGJldHdlZW4gdGhyZWFkcyBoYXMKKyAgICAgICAgYmVlbiBtb3ZlZCB0 byB0aGlzIGhlbHBlciBjbGFzcyB0b28uCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9n c3RyZWFtZXIvVmlkZW9TaW5rR1N0cmVhbWVyLmNwcDoKKyAgICAgICAgKFZpZGVvUmVuZGVyUmVx dWVzdFNjaGVkdWxlcjo6VmlkZW9SZW5kZXJSZXF1ZXN0U2NoZWR1bGVyKToKKyAgICAgICAgKFZp ZGVvUmVuZGVyUmVxdWVzdFNjaGVkdWxlcjo6c3RhcnQpOgorICAgICAgICAoVmlkZW9SZW5kZXJS ZXF1ZXN0U2NoZWR1bGVyOjpzdG9wKToKKyAgICAgICAgKFZpZGVvUmVuZGVyUmVxdWVzdFNjaGVk dWxlcjo6cmVxdWVzdFJlbmRlcik6CisgICAgICAgIChWaWRlb1JlbmRlclJlcXVlc3RTY2hlZHVs ZXI6OmlzVW5sb2NrZWQpOgorICAgICAgICAoVmlkZW9SZW5kZXJSZXF1ZXN0U2NoZWR1bGVyOjpy ZW5kZXIpOgorICAgICAgICAoX1dlYktpdFZpZGVvU2lua1ByaXZhdGU6Ol9XZWJLaXRWaWRlb1Np bmtQcml2YXRlKToKKyAgICAgICAgKHdlYmtpdFZpZGVvU2lua1JlcGFpbnRSZXF1ZXN0ZWQpOgor ICAgICAgICAod2Via2l0VmlkZW9TaW5rUmVuZGVyKToKKyAgICAgICAgKHdlYmtpdFZpZGVvU2lu a1VubG9jayk6CisgICAgICAgICh3ZWJraXRWaWRlb1NpbmtVbmxvY2tTdG9wKToKKyAgICAgICAg KHdlYmtpdFZpZGVvU2lua1N0b3ApOgorICAgICAgICAod2Via2l0VmlkZW9TaW5rU3RhcnQpOgor ICAgICAgICAoX1dlYktpdFZpZGVvU2lua1ByaXZhdGU6On5fV2ViS2l0VmlkZW9TaW5rUHJpdmF0 ZSk6IERlbGV0ZWQuCisgICAgICAgICh3ZWJraXRWaWRlb1NpbmtUaW1lb3V0Q2FsbGJhY2spOiBE ZWxldGVkLgorICAgICAgICAodW5sb2NrU2FtcGxlTXV0ZXgpOiBEZWxldGVkLgorCisyMDE1LTEx LTAzICBDYXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4KKwogICAgICAg ICBbR1N0cmVhbWVyXSBVc2UgR3N0QnVzIHN5bmMgbWVzc2FnZSBoYW5kbGVyIGFuZCBzY2hlZHVs ZSB0YXNrcyB0byB0aGUgbWFpbiB0aHJlYWQgd2l0aCBSdW5Mb29wOjpkaXNwYXRjaAogICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTUwODAwCiAKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2dzdHJlYW1lci9WaWRlb1Np bmtHU3RyZWFtZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVh bWVyL1ZpZGVvU2lua0dTdHJlYW1lci5jcHAKaW5kZXggZGZkMjQ1OC4uOTQyZDM0MSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL1ZpZGVvU2lu a0dTdHJlYW1lci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvZ3N0 cmVhbWVyL1ZpZGVvU2lua0dTdHJlYW1lci5jcHAKQEAgLTM1LDggKzM1LDggQEAKICNpbmNsdWRl IDxnbGliLmg+CiAjaW5jbHVkZSA8Z3N0L2dzdC5oPgogI2luY2x1ZGUgPGdzdC92aWRlby9nc3R2 aWRlb21ldGEuaD4KLSNpbmNsdWRlIDx3dGYvZ2xpYi9HTXV0ZXhMb2NrZXIuaD4KLSNpbmNsdWRl IDx3dGYvZ2xpYi9HVGhyZWFkU2FmZU1haW5Mb29wU291cmNlLmg+CisjaW5jbHVkZSA8d3RmL0Nv bmRpdGlvbi5oPgorI2luY2x1ZGUgPHd0Zi9SdW5Mb29wLmg+CiAKIHVzaW5nIG5hbWVzcGFjZSBX ZWJDb3JlOwogCkBAIC02NywzOCArNjcsOTMgQEAgZW51bSB7CiAKIHN0YXRpYyBndWludCB3ZWJr aXRWaWRlb1NpbmtTaWduYWxzW0xBU1RfU0lHTkFMXSA9IHsgMCwgfTsKIAotc3RydWN0IF9XZWJL aXRWaWRlb1NpbmtQcml2YXRlIHsKLSAgICBfV2ViS2l0VmlkZW9TaW5rUHJpdmF0ZSgpCitzdGF0 aWMgdm9pZCB3ZWJraXRWaWRlb1NpbmtSZXBhaW50UmVxdWVzdGVkKFdlYktpdFZpZGVvU2luayos IEdzdFNhbXBsZSopOworCitjbGFzcyBWaWRlb1JlbmRlclJlcXVlc3RTY2hlZHVsZXIgeworcHVi bGljOgorICAgIFZpZGVvUmVuZGVyUmVxdWVzdFNjaGVkdWxlcigpCisgICAgICAgIDogbV90aW1l cihSdW5Mb29wOjptYWluKCksIHRoaXMsICZWaWRlb1JlbmRlclJlcXVlc3RTY2hlZHVsZXI6OnJl bmRlcikKICAgICB7Ci0gICAgICAgIGdfbXV0ZXhfaW5pdCgmc2FtcGxlTXV0ZXgpOwotICAgICAg ICBnX2NvbmRfaW5pdCgmZGF0YUNvbmRpdGlvbik7Ci0gICAgICAgIGdzdF92aWRlb19pbmZvX2lu aXQoJmluZm8pOworI2lmIFBMQVRGT1JNKEdUSykKKyAgICAgICAgLy8gVXNlIGEgaGlnaGVyIHBy aW9yaXR5IHRoYW4gV2ViQ29yZSB0aW1lcnMgKEdfUFJJT1JJVFlfSElHSF9JRExFICsgMjApLgor ICAgICAgICBtX3RpbWVyLnNldFByaW9yaXR5KEdfUFJJT1JJVFlfSElHSF9JRExFICsgMTkpOwor I2VuZGlmCiAgICAgfQogCi0gICAgfl9XZWJLaXRWaWRlb1NpbmtQcml2YXRlKCkKKyAgICB2b2lk IHN0YXJ0KCkKICAgICB7Ci0gICAgICAgIGdfbXV0ZXhfY2xlYXIoJnNhbXBsZU11dGV4KTsKLSAg ICAgICAgZ19jb25kX2NsZWFyKCZkYXRhQ29uZGl0aW9uKTsKKyAgICAgICAgTG9ja0hvbGRlciBs b2NrZXIobV9zYW1wbGVNdXRleCk7CisgICAgICAgIG1fdW5sb2NrZWQgPSBmYWxzZTsKICAgICB9 CiAKLSAgICBHc3RTYW1wbGUqIHNhbXBsZTsKLSAgICBHVGhyZWFkU2FmZU1haW5Mb29wU291cmNl IHRpbWVvdXRTb3VyY2U7Ci0gICAgR011dGV4IHNhbXBsZU11dGV4OwotICAgIEdDb25kIGRhdGFD b25kaXRpb247CisgICAgdm9pZCBzdG9wKCkKKyAgICB7CisgICAgICAgIG1fdGltZXIuc3RvcCgp OworICAgICAgICBMb2NrSG9sZGVyIGxvY2tlcihtX3NhbXBsZU11dGV4KTsKKyAgICAgICAgbV9z YW1wbGUgPSBudWxscHRyOworICAgICAgICBtX3VubG9ja2VkID0gdHJ1ZTsKKyAgICAgICAgbV9k YXRhQ29uZGl0aW9uLm5vdGlmeU9uZSgpOworICAgIH0KIAotICAgIEdzdFZpZGVvSW5mbyBpbmZv OworICAgIHZvaWQgcmVxdWVzdFJlbmRlcihXZWJLaXRWaWRlb1NpbmsqIHNpbmssIEdSZWZQdHI8 R3N0U2FtcGxlPiYmIHNhbXBsZSkKKyAgICB7CisgICAgICAgIExvY2tIb2xkZXIgbG9ja2VyKG1f c2FtcGxlTXV0ZXgpOworICAgICAgICBtX3NhbXBsZSA9IFdURjo6bW92ZShzYW1wbGUpOworICAg ICAgICBtX3NpbmsgPSBzaW5rOworICAgICAgICBtX3RpbWVyLnN0YXJ0T25lU2hvdCgwKTsKKyAg ICAgICAgbV9kYXRhQ29uZGl0aW9uLndhaXQobV9zYW1wbGVNdXRleCk7CisgICAgfQogCi0gICAg R3N0Q2FwcyogY3VycmVudENhcHM7CisgICAgYm9vbCBpc1VubG9ja2VkKCkKKyAgICB7CisgICAg ICAgIExvY2tIb2xkZXIgbG9ja2VyKG1fc2FtcGxlTXV0ZXgpOworICAgICAgICByZXR1cm4gbV91 bmxvY2tlZDsKKyAgICB9CiAKLSAgICAvLyBJZiB0aGlzIGlzIFRSVUUgYWxsIHByb2Nlc3Npbmcg c2hvdWxkIGZpbmlzaCBBU0FQCitwcml2YXRlOgorCisgICAgdm9pZCByZW5kZXIoKQorICAgIHsK KyAgICAgICAgTG9ja0hvbGRlciBsb2NrZXIobV9zYW1wbGVNdXRleCk7CisgICAgICAgIEdSZWZQ dHI8R3N0U2FtcGxlPiBzYW1wbGUgPSBXVEY6Om1vdmUobV9zYW1wbGUpOworICAgICAgICBHUmVm UHRyPFdlYktpdFZpZGVvU2luaz4gc2luayA9IFdURjo6bW92ZShtX3NpbmspOworICAgICAgICBp ZiAoc2FtcGxlICYmICFtX3VubG9ja2VkICYmIExJS0VMWShHU1RfSVNfU0FNUExFKHNhbXBsZS5n ZXQoKSkpKQorICAgICAgICAgICAgd2Via2l0VmlkZW9TaW5rUmVwYWludFJlcXVlc3RlZChzaW5r LmdldCgpLCBzYW1wbGUuZ2V0KCkpOworICAgICAgICBtX2RhdGFDb25kaXRpb24ubm90aWZ5T25l KCk7CisgICAgfQorCisgICAgUnVuTG9vcDo6VGltZXI8VmlkZW9SZW5kZXJSZXF1ZXN0U2NoZWR1 bGVyPiBtX3RpbWVyOworICAgIExvY2sgbV9zYW1wbGVNdXRleDsKKyAgICBDb25kaXRpb24gbV9k YXRhQ29uZGl0aW9uOworICAgIEdSZWZQdHI8R3N0U2FtcGxlPiBtX3NhbXBsZTsKKyAgICBHUmVm UHRyPFdlYktpdFZpZGVvU2luaz4gbV9zaW5rOworCisgICAgLy8gSWYgdGhpcyBpcyB0cnVlIGFs bCBwcm9jZXNzaW5nIHNob3VsZCBmaW5pc2ggQVNBUAogICAgIC8vIFRoaXMgaXMgbmVjZXNzYXJ5 IGJlY2F1c2UgdGhlcmUgY291bGQgYmUgYSByYWNlIGJldHdlZW4KICAgICAvLyB1bmxvY2soKSBh bmQgcmVuZGVyKCksIHdoZXJlIHVubG9jaygpIHdpbnMsIHNpZ25hbHMgdGhlCi0gICAgLy8gR0Nv bmQsIHRoZW4gcmVuZGVyKCkgdHJpZXMgdG8gcmVuZGVyIGEgZnJhbWUgYWx0aG91Z2gKKyAgICAv LyBDb25kaXRpb24sIHRoZW4gcmVuZGVyKCkgdHJpZXMgdG8gcmVuZGVyIGEgZnJhbWUgYWx0aG91 Z2gKICAgICAvLyBldmVyeXRoaW5nIGVsc2UgaXNuJ3QgcnVubmluZyBhbnltb3JlLiBUaGlzIHdp bGwgbGVhZAogICAgIC8vIHRvIGRlYWRsb2NrcyBiZWNhdXNlIHJlbmRlcigpIGhvbGRzIHRoZSBz dHJlYW0gbG9jay4KICAgICAvLwogICAgIC8vIFByb3RlY3RlZCBieSB0aGUgc2FtcGxlIG11dGV4 Ci0gICAgYm9vbCB1bmxvY2tlZDsKKyAgICBib29sIG1fdW5sb2NrZWQgeyBmYWxzZSB9OworfTsK Kworc3RydWN0IF9XZWJLaXRWaWRlb1NpbmtQcml2YXRlIHsKKyAgICBfV2ViS2l0VmlkZW9TaW5r UHJpdmF0ZSgpCisgICAgeworICAgICAgICBnc3RfdmlkZW9faW5mb19pbml0KCZpbmZvKTsKKyAg ICB9CisKKyAgICB+X1dlYktpdFZpZGVvU2lua1ByaXZhdGUoKQorICAgIHsKKyAgICAgICAgaWYg KGN1cnJlbnRDYXBzKQorICAgICAgICAgICAgZ3N0X2NhcHNfdW5yZWYoY3VycmVudENhcHMpOwor ICAgIH0KKworICAgIFZpZGVvUmVuZGVyUmVxdWVzdFNjaGVkdWxlciBzY2hlZHVsZXI7CisgICAg R3N0VmlkZW9JbmZvIGluZm87CisgICAgR3N0Q2FwcyogY3VycmVudENhcHM7CiB9OwogCiAjZGVm aW5lIHdlYmtpdF92aWRlb19zaW5rX3BhcmVudF9jbGFzcyBwYXJlbnRfY2xhc3MKQEAgLTExMiw0 MiArMTY3LDI0IEBAIHN0YXRpYyB2b2lkIHdlYmtpdF92aWRlb19zaW5rX2luaXQoV2ViS2l0Vmlk ZW9TaW5rKiBzaW5rKQogICAgIG5ldyAoc2luay0+cHJpdikgV2ViS2l0VmlkZW9TaW5rUHJpdmF0 ZSgpOwogfQogCi1zdGF0aWMgdm9pZCB3ZWJraXRWaWRlb1NpbmtUaW1lb3V0Q2FsbGJhY2soV2Vi S2l0VmlkZW9TaW5rKiBzaW5rKQorc3RhdGljIHZvaWQgd2Via2l0VmlkZW9TaW5rUmVwYWludFJl cXVlc3RlZChXZWJLaXRWaWRlb1NpbmsqIHNpbmssIEdzdFNhbXBsZSogc2FtcGxlKQogewotICAg IFdlYktpdFZpZGVvU2lua1ByaXZhdGUqIHByaXYgPSBzaW5rLT5wcml2OwotCi0gICAgV1RGOjpH TXV0ZXhMb2NrZXI8R011dGV4PiBsb2NrKHByaXYtPnNhbXBsZU11dGV4KTsKLSAgICBHc3RTYW1w bGUqIHNhbXBsZSA9IHByaXYtPnNhbXBsZTsKLSAgICBwcml2LT5zYW1wbGUgPSAwOwotCi0gICAg aWYgKCFzYW1wbGUgfHwgcHJpdi0+dW5sb2NrZWQgfHwgVU5MSUtFTFkoIUdTVF9JU19TQU1QTEUo c2FtcGxlKSkpIHsKLSAgICAgICAgZ19jb25kX3NpZ25hbCgmcHJpdi0+ZGF0YUNvbmRpdGlvbik7 Ci0gICAgICAgIHJldHVybjsKLSAgICB9Ci0KICAgICBnX3NpZ25hbF9lbWl0KHNpbmssIHdlYmtp dFZpZGVvU2lua1NpZ25hbHNbUkVQQUlOVF9SRVFVRVNURURdLCAwLCBzYW1wbGUpOwotICAgIGdz dF9zYW1wbGVfdW5yZWYoc2FtcGxlKTsKLSAgICBnX2NvbmRfc2lnbmFsKCZwcml2LT5kYXRhQ29u ZGl0aW9uKTsKIH0KIAogc3RhdGljIEdzdEZsb3dSZXR1cm4gd2Via2l0VmlkZW9TaW5rUmVuZGVy KEdzdEJhc2VTaW5rKiBiYXNlU2luaywgR3N0QnVmZmVyKiBidWZmZXIpCiB7CiAgICAgV2ViS2l0 VmlkZW9TaW5rKiBzaW5rID0gV0VCS0lUX1ZJREVPX1NJTksoYmFzZVNpbmspOwogICAgIFdlYktp dFZpZGVvU2lua1ByaXZhdGUqIHByaXYgPSBzaW5rLT5wcml2OwotCi0gICAgV1RGOjpHTXV0ZXhM b2NrZXI8R011dGV4PiBsb2NrKHByaXYtPnNhbXBsZU11dGV4KTsKLQotICAgIGlmIChwcml2LT51 bmxvY2tlZCkKKyAgICBpZiAocHJpdi0+c2NoZWR1bGVyLmlzVW5sb2NrZWQoKSkKICAgICAgICAg cmV0dXJuIEdTVF9GTE9XX09LOwogCi0gICAgcHJpdi0+c2FtcGxlID0gZ3N0X3NhbXBsZV9uZXco YnVmZmVyLCBwcml2LT5jdXJyZW50Q2FwcywgMCwgMCk7CisgICAgR1JlZlB0cjxHc3RTYW1wbGU+ IHNhbXBsZSA9IGFkb3B0R1JlZihnc3Rfc2FtcGxlX25ldyhidWZmZXIsIHByaXYtPmN1cnJlbnRD YXBzLCBudWxscHRyLCBudWxscHRyKSk7CiAKICAgICAvLyBUaGUgdmlkZW8gaW5mbyBzdHJ1Y3R1 cmUgaXMgdmFsaWQgb25seSBpZiB0aGUgc2luayBoYW5kbGVkIGFuIGFsbG9jYXRpb24gcXVlcnku CiAgICAgR3N0VmlkZW9Gb3JtYXQgZm9ybWF0ID0gR1NUX1ZJREVPX0lORk9fRk9STUFUKCZwcml2 LT5pbmZvKTsKLSAgICBpZiAoZm9ybWF0ID09IEdTVF9WSURFT19GT1JNQVRfVU5LTk9XTikgewot ICAgICAgICBnc3Rfc2FtcGxlX3VucmVmKHByaXYtPnNhbXBsZSk7CisgICAgaWYgKGZvcm1hdCA9 PSBHU1RfVklERU9fRk9STUFUX1VOS05PV04pCiAgICAgICAgIHJldHVybiBHU1RfRkxPV19FUlJP UjsKLSAgICB9CiAKICNpZiAhKFVTRShURVhUVVJFX01BUFBFUl9HTCkgJiYgIVVTRShDT09SRElO QVRFRF9HUkFQSElDUykpCiAgICAgLy8gQ2Fpcm8ncyBBUkdCIGhhcyBwcmUtbXVsdGlwbGllZCBh bHBoYSB3aGlsZSBHU3RyZWFtZXIncyBkb2Vzbid0LgpAQCAtMTc0LDcgKzIxMSw2IEBAIHN0YXRp YyBHc3RGbG93UmV0dXJuIHdlYmtpdFZpZGVvU2lua1JlbmRlcihHc3RCYXNlU2luayogYmFzZVNp bmssIEdzdEJ1ZmZlciogYnVmCiAgICAgICAgIEdzdFZpZGVvRnJhbWUgZGVzdGluYXRpb25GcmFt ZTsKIAogICAgICAgICBpZiAoIWdzdF92aWRlb19mcmFtZV9tYXAoJnNvdXJjZUZyYW1lLCAmcHJp di0+aW5mbywgYnVmZmVyLCBHU1RfTUFQX1JFQUQpKSB7Ci0gICAgICAgICAgICBnc3Rfc2FtcGxl X3VucmVmKHByaXYtPnNhbXBsZSk7CiAgICAgICAgICAgICBnc3RfYnVmZmVyX3VucmVmKG5ld0J1 ZmZlcik7CiAgICAgICAgICAgICByZXR1cm4gR1NUX0ZMT1dfRVJST1I7CiAgICAgICAgIH0KQEAg LTIwOSwxOSArMjQ1LDExIEBAIHN0YXRpYyBHc3RGbG93UmV0dXJuIHdlYmtpdFZpZGVvU2lua1Jl bmRlcihHc3RCYXNlU2luayogYmFzZVNpbmssIEdzdEJ1ZmZlciogYnVmCiAKICAgICAgICAgZ3N0 X3ZpZGVvX2ZyYW1lX3VubWFwKCZzb3VyY2VGcmFtZSk7CiAgICAgICAgIGdzdF92aWRlb19mcmFt ZV91bm1hcCgmZGVzdGluYXRpb25GcmFtZSk7Ci0gICAgICAgIGdzdF9zYW1wbGVfdW5yZWYocHJp di0+c2FtcGxlKTsKLSAgICAgICAgcHJpdi0+c2FtcGxlID0gZ3N0X3NhbXBsZV9uZXcobmV3QnVm ZmVyLCBwcml2LT5jdXJyZW50Q2FwcywgMCwgMCk7CisgICAgICAgIHNhbXBsZSA9IGFkb3B0R1Jl Zihnc3Rfc2FtcGxlX25ldyhuZXdCdWZmZXIsIHByaXYtPmN1cnJlbnRDYXBzLCBudWxscHRyLCBu dWxscHRyKSk7CiAgICAgfQogI2VuZGlmCiAKLSAgICAvLyBUaGlzIHNob3VsZCBsaWtlbHkgdXNl IGEgbG93ZXIgcHJpb3JpdHksIGJ1dCBnbGliIGN1cnJlbnRseSBzdGFydmVzCi0gICAgLy8gbG93 ZXIgcHJpb3JpdHkgc291cmNlcy4KLSAgICAvLyBTZWU6IGh0dHBzOi8vYnVnemlsbGEuZ25vbWUu b3JnL3Nob3dfYnVnLmNnaT9pZD02MTA4MzAuCi0gICAgR1JlZlB0cjxXZWJLaXRWaWRlb1Npbms+ IHByb3RlY3RvcihzaW5rKTsKLSAgICBwcml2LT50aW1lb3V0U291cmNlLnNjaGVkdWxlKCJbV2Vi S2l0XSB3ZWJraXRWaWRlb1NpbmtUaW1lb3V0Q2FsbGJhY2siLAotICAgICAgICBzdGQ6OmZ1bmN0 aW9uPHZvaWQoKT4oW3Byb3RlY3Rvcl0geyB3ZWJraXRWaWRlb1NpbmtUaW1lb3V0Q2FsbGJhY2so cHJvdGVjdG9yLmdldCgpKTsgfSkpOwotCi0gICAgZ19jb25kX3dhaXQoJnByaXYtPmRhdGFDb25k aXRpb24sICZwcml2LT5zYW1wbGVNdXRleCk7CisgICAgcHJpdi0+c2NoZWR1bGVyLnJlcXVlc3RS ZW5kZXIoc2luaywgV1RGOjptb3ZlKHNhbXBsZSkpOwogICAgIHJldHVybiBHU1RfRkxPV19PSzsK IH0KIApAQCAtMjMxLDI1ICsyNTksMTEgQEAgc3RhdGljIHZvaWQgd2Via2l0VmlkZW9TaW5rRmlu YWxpemUoR09iamVjdCogb2JqZWN0KQogICAgIEdfT0JKRUNUX0NMQVNTKHBhcmVudF9jbGFzcykt PmZpbmFsaXplKG9iamVjdCk7CiB9CiAKLXN0YXRpYyB2b2lkIHVubG9ja1NhbXBsZU11dGV4KFdl YktpdFZpZGVvU2lua1ByaXZhdGUqIHByaXYpCi17Ci0gICAgV1RGOjpHTXV0ZXhMb2NrZXI8R011 dGV4PiBsb2NrKHByaXYtPnNhbXBsZU11dGV4KTsKLQotICAgIGlmIChwcml2LT5zYW1wbGUpIHsK LSAgICAgICAgZ3N0X3NhbXBsZV91bnJlZihwcml2LT5zYW1wbGUpOwotICAgICAgICBwcml2LT5z YW1wbGUgPSAwOwotICAgIH0KLQotICAgIHByaXYtPnVubG9ja2VkID0gdHJ1ZTsKLQotICAgIGdf Y29uZF9zaWduYWwoJnByaXYtPmRhdGFDb25kaXRpb24pOwotfQotCiBzdGF0aWMgZ2Jvb2xlYW4g d2Via2l0VmlkZW9TaW5rVW5sb2NrKEdzdEJhc2VTaW5rKiBiYXNlU2luaykKIHsKLSAgICBXZWJL aXRWaWRlb1NpbmsqIHNpbmsgPSBXRUJLSVRfVklERU9fU0lOSyhiYXNlU2luayk7CisgICAgV2Vi S2l0VmlkZW9TaW5rUHJpdmF0ZSogcHJpdiA9IFdFQktJVF9WSURFT19TSU5LKGJhc2VTaW5rKS0+ cHJpdjsKIAotICAgIHVubG9ja1NhbXBsZU11dGV4KHNpbmstPnByaXYpOworICAgIHByaXYtPnNj aGVkdWxlci5zdG9wKCk7CiAKICAgICByZXR1cm4gR1NUX0NBTExfUEFSRU5UX1dJVEhfREVGQVVM VChHU1RfQkFTRV9TSU5LX0NMQVNTLCB1bmxvY2ssIChiYXNlU2luayksIFRSVUUpOwogfQpAQCAt MjU4LDEwICsyNzIsNyBAQCBzdGF0aWMgZ2Jvb2xlYW4gd2Via2l0VmlkZW9TaW5rVW5sb2NrU3Rv cChHc3RCYXNlU2luayogYmFzZVNpbmspCiB7CiAgICAgV2ViS2l0VmlkZW9TaW5rUHJpdmF0ZSog cHJpdiA9IFdFQktJVF9WSURFT19TSU5LKGJhc2VTaW5rKS0+cHJpdjsKIAotICAgIHsKLSAgICAg ICAgV1RGOjpHTXV0ZXhMb2NrZXI8R011dGV4PiBsb2NrKHByaXYtPnNhbXBsZU11dGV4KTsKLSAg ICAgICAgcHJpdi0+dW5sb2NrZWQgPSBmYWxzZTsKLSAgICB9CisgICAgcHJpdi0+c2NoZWR1bGVy LnN0YXJ0KCk7CiAKICAgICByZXR1cm4gR1NUX0NBTExfUEFSRU5UX1dJVEhfREVGQVVMVChHU1Rf QkFTRV9TSU5LX0NMQVNTLCB1bmxvY2tfc3RvcCwgKGJhc2VTaW5rKSwgVFJVRSk7CiB9CkBAIC0y NzAsMTEgKzI4MSwxMCBAQCBzdGF0aWMgZ2Jvb2xlYW4gd2Via2l0VmlkZW9TaW5rU3RvcChHc3RC YXNlU2luayogYmFzZVNpbmspCiB7CiAgICAgV2ViS2l0VmlkZW9TaW5rUHJpdmF0ZSogcHJpdiA9 IFdFQktJVF9WSURFT19TSU5LKGJhc2VTaW5rKS0+cHJpdjsKIAotICAgIHVubG9ja1NhbXBsZU11 dGV4KHByaXYpOwotCisgICAgcHJpdi0+c2NoZWR1bGVyLnN0b3AoKTsKICAgICBpZiAocHJpdi0+ Y3VycmVudENhcHMpIHsKICAgICAgICAgZ3N0X2NhcHNfdW5yZWYocHJpdi0+Y3VycmVudENhcHMp OwotICAgICAgICBwcml2LT5jdXJyZW50Q2FwcyA9IDA7CisgICAgICAgIHByaXYtPmN1cnJlbnRD YXBzID0gbnVsbHB0cjsKICAgICB9CiAKICAgICByZXR1cm4gVFJVRTsKQEAgLTI4NCw4ICsyOTQs OCBAQCBzdGF0aWMgZ2Jvb2xlYW4gd2Via2l0VmlkZW9TaW5rU3RhcnQoR3N0QmFzZVNpbmsqIGJh c2VTaW5rKQogewogICAgIFdlYktpdFZpZGVvU2lua1ByaXZhdGUqIHByaXYgPSBXRUJLSVRfVklE RU9fU0lOSyhiYXNlU2luayktPnByaXY7CiAKLSAgICBXVEY6OkdNdXRleExvY2tlcjxHTXV0ZXg+ IGxvY2socHJpdi0+c2FtcGxlTXV0ZXgpOwotICAgIHByaXYtPnVubG9ja2VkID0gZmFsc2U7Cisg ICAgcHJpdi0+c2NoZWR1bGVyLnN0YXJ0KCk7CisKICAgICByZXR1cm4gVFJVRTsKIH0KIAo= 264784 2015-11-04 02:39:38 -0800 2015-11-05 00:06:53 -0800 Updated patch wcore-gst-sink-timer.diff text/plain 11801 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA2MTIzZDU5Li5iZTg4ZjNjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzUg QEAKKzIwMTUtMTEtMDMgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29t PgorCisgICAgICAgIFtHU3RyZWFtZXJdIFVzZSBSdW5Mb29wOjpUaW1lciBpbnN0ZWFkIG9mIEdN YWluTG9vcFNvdXJjZSBpbiB2aWRlbyBzaW5rCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0xNTA4MDcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICBTaW5jZSB3ZSBhbHdheXMgd2FpdCB1bnRpbCB0aGUgc2FtcGxl IGlzIGFjdHVhbGx5IHJlbmRlcmVkIHdlCisgICAgICAgIGRvbid0IHJlYWxseSBuZWVkIGVpdGhl ciBhIHRocmVhZCBzYWZlIG1haW4gbG9vcCBzb3VyY2UsIG5vcgorICAgICAgICBjYW5jZWxsaW5n IGlmIGFscmVhZHkgcmVxdWVzdGVkIGFuZCBvdGhlciB0aGluZ3MgR01haW5Mb29wU291cmNlIGRv ZXMuCisgICAgICAgIFRoaXMgYWRkcyBhIGhlbHBlciBjbGFzcyBWaWRlb1JlbmRlclJlcXVlc3RT Y2hlZHVsZXIgdG8gdXNlIHRoZQorICAgICAgICBSdW5Mb29wOjpUaW1lci4gQWxsIHRoZSBsb2dp YyB0byBzeW5jcm9uaXplIGJldHdlZW4gdGhyZWFkcyBoYXMKKyAgICAgICAgYmVlbiBtb3ZlZCB0 byB0aGlzIGhlbHBlciBjbGFzcyB0b28uCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9n c3RyZWFtZXIvVmlkZW9TaW5rR1N0cmVhbWVyLmNwcDoKKyAgICAgICAgKFZpZGVvUmVuZGVyUmVx dWVzdFNjaGVkdWxlcjo6VmlkZW9SZW5kZXJSZXF1ZXN0U2NoZWR1bGVyKToKKyAgICAgICAgKFZp ZGVvUmVuZGVyUmVxdWVzdFNjaGVkdWxlcjo6c3RhcnQpOgorICAgICAgICAoVmlkZW9SZW5kZXJS ZXF1ZXN0U2NoZWR1bGVyOjpzdG9wKToKKyAgICAgICAgKFZpZGVvUmVuZGVyUmVxdWVzdFNjaGVk dWxlcjo6cmVxdWVzdFJlbmRlcik6CisgICAgICAgIChWaWRlb1JlbmRlclJlcXVlc3RTY2hlZHVs ZXI6OmlzVW5sb2NrZWQpOgorICAgICAgICAoVmlkZW9SZW5kZXJSZXF1ZXN0U2NoZWR1bGVyOjpy ZW5kZXIpOgorICAgICAgICAoX1dlYktpdFZpZGVvU2lua1ByaXZhdGU6Ol9XZWJLaXRWaWRlb1Np bmtQcml2YXRlKToKKyAgICAgICAgKHdlYmtpdFZpZGVvU2lua1JlcGFpbnRSZXF1ZXN0ZWQpOgor ICAgICAgICAod2Via2l0VmlkZW9TaW5rUmVuZGVyKToKKyAgICAgICAgKHdlYmtpdFZpZGVvU2lu a1VubG9jayk6CisgICAgICAgICh3ZWJraXRWaWRlb1NpbmtVbmxvY2tTdG9wKToKKyAgICAgICAg KHdlYmtpdFZpZGVvU2lua1N0b3ApOgorICAgICAgICAod2Via2l0VmlkZW9TaW5rU3RhcnQpOgor ICAgICAgICAoX1dlYktpdFZpZGVvU2lua1ByaXZhdGU6On5fV2ViS2l0VmlkZW9TaW5rUHJpdmF0 ZSk6IERlbGV0ZWQuCisgICAgICAgICh3ZWJraXRWaWRlb1NpbmtUaW1lb3V0Q2FsbGJhY2spOiBE ZWxldGVkLgorICAgICAgICAodW5sb2NrU2FtcGxlTXV0ZXgpOiBEZWxldGVkLgorCiAyMDE1LTEx LTA0ICBDYXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4KIAogICAgICAg ICBbR1N0cmVhbWVyXSBVc2UgUnVuTG9vcDo6VGltZXIgZm9yIHJlYWR5IHN0YXRlIHRpbWVyIGlu IE1lZGlhUGxheWVyUHJpdmF0ZUdTdHJlYW1lcgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvZ3N0cmVhbWVyL1ZpZGVvU2lua0dTdHJlYW1lci5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvVmlkZW9TaW5rR1N0cmVhbWVy LmNwcAppbmRleCBkZmQyNDU4Li5kNmQyMzI2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvVmlkZW9TaW5rR1N0cmVhbWVyLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9nc3RyZWFtZXIvVmlkZW9TaW5rR1N0cmVh bWVyLmNwcApAQCAtMzUsOCArMzUsOCBAQAogI2luY2x1ZGUgPGdsaWIuaD4KICNpbmNsdWRlIDxn c3QvZ3N0Lmg+CiAjaW5jbHVkZSA8Z3N0L3ZpZGVvL2dzdHZpZGVvbWV0YS5oPgotI2luY2x1ZGUg PHd0Zi9nbGliL0dNdXRleExvY2tlci5oPgotI2luY2x1ZGUgPHd0Zi9nbGliL0dUaHJlYWRTYWZl TWFpbkxvb3BTb3VyY2UuaD4KKyNpbmNsdWRlIDx3dGYvQ29uZGl0aW9uLmg+CisjaW5jbHVkZSA8 d3RmL1J1bkxvb3AuaD4KIAogdXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CiAKQEAgLTY3LDM4ICs2 Nyw5NSBAQCBlbnVtIHsKIAogc3RhdGljIGd1aW50IHdlYmtpdFZpZGVvU2lua1NpZ25hbHNbTEFT VF9TSUdOQUxdID0geyAwLCB9OwogCi1zdHJ1Y3QgX1dlYktpdFZpZGVvU2lua1ByaXZhdGUgewot ICAgIF9XZWJLaXRWaWRlb1NpbmtQcml2YXRlKCkKK3N0YXRpYyB2b2lkIHdlYmtpdFZpZGVvU2lu a1JlcGFpbnRSZXF1ZXN0ZWQoV2ViS2l0VmlkZW9TaW5rKiwgR3N0U2FtcGxlKik7CitzdGF0aWMg R1JlZlB0cjxHc3RTYW1wbGU+IHdlYmtpdFZpZGVvU2lua1JlcXVlc3RSZW5kZXIoV2ViS2l0Vmlk ZW9TaW5rKiwgR3N0QnVmZmVyKik7CisKK2NsYXNzIFZpZGVvUmVuZGVyUmVxdWVzdFNjaGVkdWxl ciB7CitwdWJsaWM6CisgICAgVmlkZW9SZW5kZXJSZXF1ZXN0U2NoZWR1bGVyKCkKKyAgICAgICAg OiBtX3RpbWVyKFJ1bkxvb3A6Om1haW4oKSwgdGhpcywgJlZpZGVvUmVuZGVyUmVxdWVzdFNjaGVk dWxlcjo6cmVuZGVyKQogICAgIHsKLSAgICAgICAgZ19tdXRleF9pbml0KCZzYW1wbGVNdXRleCk7 Ci0gICAgICAgIGdfY29uZF9pbml0KCZkYXRhQ29uZGl0aW9uKTsKLSAgICAgICAgZ3N0X3ZpZGVv X2luZm9faW5pdCgmaW5mbyk7CisjaWYgUExBVEZPUk0oR1RLKQorICAgICAgICAvLyBVc2UgYSBo aWdoZXIgcHJpb3JpdHkgdGhhbiBXZWJDb3JlIHRpbWVycyAoR19QUklPUklUWV9ISUdIX0lETEUg KyAyMCkuCisgICAgICAgIG1fdGltZXIuc2V0UHJpb3JpdHkoR19QUklPUklUWV9ISUdIX0lETEUg KyAxOSk7CisjZW5kaWYKICAgICB9CiAKLSAgICB+X1dlYktpdFZpZGVvU2lua1ByaXZhdGUoKQor ICAgIHZvaWQgc3RhcnQoKQogICAgIHsKLSAgICAgICAgZ19tdXRleF9jbGVhcigmc2FtcGxlTXV0 ZXgpOwotICAgICAgICBnX2NvbmRfY2xlYXIoJmRhdGFDb25kaXRpb24pOworICAgICAgICBMb2Nr SG9sZGVyIGxvY2tlcihtX3NhbXBsZU11dGV4KTsKKyAgICAgICAgbV91bmxvY2tlZCA9IGZhbHNl OwogICAgIH0KIAotICAgIEdzdFNhbXBsZSogc2FtcGxlOwotICAgIEdUaHJlYWRTYWZlTWFpbkxv b3BTb3VyY2UgdGltZW91dFNvdXJjZTsKLSAgICBHTXV0ZXggc2FtcGxlTXV0ZXg7Ci0gICAgR0Nv bmQgZGF0YUNvbmRpdGlvbjsKKyAgICB2b2lkIHN0b3AoKQorICAgIHsKKyAgICAgICAgTG9ja0hv bGRlciBsb2NrZXIobV9zYW1wbGVNdXRleCk7CisgICAgICAgIG1fdGltZXIuc3RvcCgpOworICAg ICAgICBtX3NhbXBsZSA9IG51bGxwdHI7CisgICAgICAgIG1fdW5sb2NrZWQgPSB0cnVlOworICAg ICAgICBtX2RhdGFDb25kaXRpb24ubm90aWZ5T25lKCk7CisgICAgfQogCi0gICAgR3N0VmlkZW9J bmZvIGluZm87CisgICAgYm9vbCByZXF1ZXN0UmVuZGVyKFdlYktpdFZpZGVvU2luayogc2luaywg R3N0QnVmZmVyKiBidWZmZXIpCisgICAgeworICAgICAgICBMb2NrSG9sZGVyIGxvY2tlcihtX3Nh bXBsZU11dGV4KTsKKyAgICAgICAgaWYgKG1fdW5sb2NrZWQpCisgICAgICAgICAgICByZXR1cm4g dHJ1ZTsKKworICAgICAgICBtX3NhbXBsZSA9IHdlYmtpdFZpZGVvU2lua1JlcXVlc3RSZW5kZXIo c2luaywgYnVmZmVyKTsKKyAgICAgICAgaWYgKCFtX3NhbXBsZSkKKyAgICAgICAgICAgIHJldHVy biBmYWxzZTsKKworICAgICAgICBtX3NpbmsgPSBzaW5rOworICAgICAgICBtX3RpbWVyLnN0YXJ0 T25lU2hvdCgwKTsKKyAgICAgICAgbV9kYXRhQ29uZGl0aW9uLndhaXQobV9zYW1wbGVNdXRleCk7 CisgICAgICAgIHJldHVybiB0cnVlOworICAgIH0KIAotICAgIEdzdENhcHMqIGN1cnJlbnRDYXBz OworcHJpdmF0ZToKKworICAgIHZvaWQgcmVuZGVyKCkKKyAgICB7CisgICAgICAgIExvY2tIb2xk ZXIgbG9ja2VyKG1fc2FtcGxlTXV0ZXgpOworICAgICAgICBHUmVmUHRyPEdzdFNhbXBsZT4gc2Ft cGxlID0gV1RGOjptb3ZlKG1fc2FtcGxlKTsKKyAgICAgICAgR1JlZlB0cjxXZWJLaXRWaWRlb1Np bms+IHNpbmsgPSBXVEY6Om1vdmUobV9zaW5rKTsKKyAgICAgICAgaWYgKHNhbXBsZSAmJiAhbV91 bmxvY2tlZCAmJiBMSUtFTFkoR1NUX0lTX1NBTVBMRShzYW1wbGUuZ2V0KCkpKSkKKyAgICAgICAg ICAgIHdlYmtpdFZpZGVvU2lua1JlcGFpbnRSZXF1ZXN0ZWQoc2luay5nZXQoKSwgc2FtcGxlLmdl dCgpKTsKKyAgICAgICAgbV9kYXRhQ29uZGl0aW9uLm5vdGlmeU9uZSgpOworICAgIH0KIAotICAg IC8vIElmIHRoaXMgaXMgVFJVRSBhbGwgcHJvY2Vzc2luZyBzaG91bGQgZmluaXNoIEFTQVAKKyAg ICBSdW5Mb29wOjpUaW1lcjxWaWRlb1JlbmRlclJlcXVlc3RTY2hlZHVsZXI+IG1fdGltZXI7Cisg ICAgTG9jayBtX3NhbXBsZU11dGV4OworICAgIENvbmRpdGlvbiBtX2RhdGFDb25kaXRpb247Cisg ICAgR1JlZlB0cjxHc3RTYW1wbGU+IG1fc2FtcGxlOworICAgIEdSZWZQdHI8V2ViS2l0VmlkZW9T aW5rPiBtX3Npbms7CisKKyAgICAvLyBJZiB0aGlzIGlzIHRydWUgYWxsIHByb2Nlc3Npbmcgc2hv dWxkIGZpbmlzaCBBU0FQCiAgICAgLy8gVGhpcyBpcyBuZWNlc3NhcnkgYmVjYXVzZSB0aGVyZSBj b3VsZCBiZSBhIHJhY2UgYmV0d2VlbgogICAgIC8vIHVubG9jaygpIGFuZCByZW5kZXIoKSwgd2hl cmUgdW5sb2NrKCkgd2lucywgc2lnbmFscyB0aGUKLSAgICAvLyBHQ29uZCwgdGhlbiByZW5kZXIo KSB0cmllcyB0byByZW5kZXIgYSBmcmFtZSBhbHRob3VnaAorICAgIC8vIENvbmRpdGlvbiwgdGhl biByZW5kZXIoKSB0cmllcyB0byByZW5kZXIgYSBmcmFtZSBhbHRob3VnaAogICAgIC8vIGV2ZXJ5 dGhpbmcgZWxzZSBpc24ndCBydW5uaW5nIGFueW1vcmUuIFRoaXMgd2lsbCBsZWFkCiAgICAgLy8g dG8gZGVhZGxvY2tzIGJlY2F1c2UgcmVuZGVyKCkgaG9sZHMgdGhlIHN0cmVhbSBsb2NrLgogICAg IC8vCiAgICAgLy8gUHJvdGVjdGVkIGJ5IHRoZSBzYW1wbGUgbXV0ZXgKLSAgICBib29sIHVubG9j a2VkOworICAgIGJvb2wgbV91bmxvY2tlZCB7IGZhbHNlIH07Cit9OworCitzdHJ1Y3QgX1dlYktp dFZpZGVvU2lua1ByaXZhdGUgeworICAgIF9XZWJLaXRWaWRlb1NpbmtQcml2YXRlKCkKKyAgICB7 CisgICAgICAgIGdzdF92aWRlb19pbmZvX2luaXQoJmluZm8pOworICAgIH0KKworICAgIH5fV2Vi S2l0VmlkZW9TaW5rUHJpdmF0ZSgpCisgICAgeworICAgICAgICBpZiAoY3VycmVudENhcHMpCisg ICAgICAgICAgICBnc3RfY2Fwc191bnJlZihjdXJyZW50Q2Fwcyk7CisgICAgfQorCisgICAgVmlk ZW9SZW5kZXJSZXF1ZXN0U2NoZWR1bGVyIHNjaGVkdWxlcjsKKyAgICBHc3RWaWRlb0luZm8gaW5m bzsKKyAgICBHc3RDYXBzKiBjdXJyZW50Q2FwczsKIH07CiAKICNkZWZpbmUgd2Via2l0X3ZpZGVv X3NpbmtfcGFyZW50X2NsYXNzIHBhcmVudF9jbGFzcwpAQCAtMTEyLDQyICsxNjksMjAgQEAgc3Rh dGljIHZvaWQgd2Via2l0X3ZpZGVvX3NpbmtfaW5pdChXZWJLaXRWaWRlb1NpbmsqIHNpbmspCiAg ICAgbmV3IChzaW5rLT5wcml2KSBXZWJLaXRWaWRlb1NpbmtQcml2YXRlKCk7CiB9CiAKLXN0YXRp YyB2b2lkIHdlYmtpdFZpZGVvU2lua1RpbWVvdXRDYWxsYmFjayhXZWJLaXRWaWRlb1NpbmsqIHNp bmspCitzdGF0aWMgdm9pZCB3ZWJraXRWaWRlb1NpbmtSZXBhaW50UmVxdWVzdGVkKFdlYktpdFZp ZGVvU2luayogc2luaywgR3N0U2FtcGxlKiBzYW1wbGUpCiB7Ci0gICAgV2ViS2l0VmlkZW9TaW5r UHJpdmF0ZSogcHJpdiA9IHNpbmstPnByaXY7Ci0KLSAgICBXVEY6OkdNdXRleExvY2tlcjxHTXV0 ZXg+IGxvY2socHJpdi0+c2FtcGxlTXV0ZXgpOwotICAgIEdzdFNhbXBsZSogc2FtcGxlID0gcHJp di0+c2FtcGxlOwotICAgIHByaXYtPnNhbXBsZSA9IDA7Ci0KLSAgICBpZiAoIXNhbXBsZSB8fCBw cml2LT51bmxvY2tlZCB8fCBVTkxJS0VMWSghR1NUX0lTX1NBTVBMRShzYW1wbGUpKSkgewotICAg ICAgICBnX2NvbmRfc2lnbmFsKCZwcml2LT5kYXRhQ29uZGl0aW9uKTsKLSAgICAgICAgcmV0dXJu OwotICAgIH0KLQogICAgIGdfc2lnbmFsX2VtaXQoc2luaywgd2Via2l0VmlkZW9TaW5rU2lnbmFs c1tSRVBBSU5UX1JFUVVFU1RFRF0sIDAsIHNhbXBsZSk7Ci0gICAgZ3N0X3NhbXBsZV91bnJlZihz YW1wbGUpOwotICAgIGdfY29uZF9zaWduYWwoJnByaXYtPmRhdGFDb25kaXRpb24pOwogfQogCi1z dGF0aWMgR3N0Rmxvd1JldHVybiB3ZWJraXRWaWRlb1NpbmtSZW5kZXIoR3N0QmFzZVNpbmsqIGJh c2VTaW5rLCBHc3RCdWZmZXIqIGJ1ZmZlcikKK3N0YXRpYyBHUmVmUHRyPEdzdFNhbXBsZT4gd2Vi a2l0VmlkZW9TaW5rUmVxdWVzdFJlbmRlcihXZWJLaXRWaWRlb1NpbmsqIHNpbmssIEdzdEJ1ZmZl ciogYnVmZmVyKQogewotICAgIFdlYktpdFZpZGVvU2luayogc2luayA9IFdFQktJVF9WSURFT19T SU5LKGJhc2VTaW5rKTsKICAgICBXZWJLaXRWaWRlb1NpbmtQcml2YXRlKiBwcml2ID0gc2luay0+ cHJpdjsKLQotICAgIFdURjo6R011dGV4TG9ja2VyPEdNdXRleD4gbG9jayhwcml2LT5zYW1wbGVN dXRleCk7Ci0KLSAgICBpZiAocHJpdi0+dW5sb2NrZWQpCi0gICAgICAgIHJldHVybiBHU1RfRkxP V19PSzsKLQotICAgIHByaXYtPnNhbXBsZSA9IGdzdF9zYW1wbGVfbmV3KGJ1ZmZlciwgcHJpdi0+ Y3VycmVudENhcHMsIDAsIDApOworICAgIEdSZWZQdHI8R3N0U2FtcGxlPiBzYW1wbGUgPSBhZG9w dEdSZWYoZ3N0X3NhbXBsZV9uZXcoYnVmZmVyLCBwcml2LT5jdXJyZW50Q2FwcywgbnVsbHB0ciwg bnVsbHB0cikpOwogCiAgICAgLy8gVGhlIHZpZGVvIGluZm8gc3RydWN0dXJlIGlzIHZhbGlkIG9u bHkgaWYgdGhlIHNpbmsgaGFuZGxlZCBhbiBhbGxvY2F0aW9uIHF1ZXJ5LgogICAgIEdzdFZpZGVv Rm9ybWF0IGZvcm1hdCA9IEdTVF9WSURFT19JTkZPX0ZPUk1BVCgmcHJpdi0+aW5mbyk7Ci0gICAg aWYgKGZvcm1hdCA9PSBHU1RfVklERU9fRk9STUFUX1VOS05PV04pIHsKLSAgICAgICAgZ3N0X3Nh bXBsZV91bnJlZihwcml2LT5zYW1wbGUpOwotICAgICAgICByZXR1cm4gR1NUX0ZMT1dfRVJST1I7 Ci0gICAgfQorICAgIGlmIChmb3JtYXQgPT0gR1NUX1ZJREVPX0ZPUk1BVF9VTktOT1dOKQorICAg ICAgICByZXR1cm4gbnVsbHB0cjsKIAogI2lmICEoVVNFKFRFWFRVUkVfTUFQUEVSX0dMKSAmJiAh VVNFKENPT1JESU5BVEVEX0dSQVBISUNTKSkKICAgICAvLyBDYWlybydzIEFSR0IgaGFzIHByZS1t dWx0aXBsaWVkIGFscGhhIHdoaWxlIEdTdHJlYW1lcidzIGRvZXNuJ3QuCkBAIC0xNjMsNyArMTk4 LDcgQEAgc3RhdGljIEdzdEZsb3dSZXR1cm4gd2Via2l0VmlkZW9TaW5rUmVuZGVyKEdzdEJhc2VT aW5rKiBiYXNlU2luaywgR3N0QnVmZmVyKiBidWYKICAgICAgICAgLy8gQ2hlY2sgaWYgYWxsb2Nh dGlvbiBmYWlsZWQuCiAgICAgICAgIGlmIChVTkxJS0VMWSghbmV3QnVmZmVyKSkgewogICAgICAg ICAgICAgZ3N0X2J1ZmZlcl91bnJlZihidWZmZXIpOwotICAgICAgICAgICAgcmV0dXJuIEdTVF9G TE9XX0VSUk9SOworICAgICAgICAgICAgcmV0dXJuIG51bGxwdHI7CiAgICAgICAgIH0KIAogICAg ICAgICAvLyBXZSBkb24ndCB1c2UgQ29sb3I6OnByZW11bHRpcGxpZWRBUkdCRnJvbUNvbG9yKCkg aGVyZSBiZWNhdXNlCkBAIC0xNzQsMTQgKzIwOSwxMyBAQCBzdGF0aWMgR3N0Rmxvd1JldHVybiB3 ZWJraXRWaWRlb1NpbmtSZW5kZXIoR3N0QmFzZVNpbmsqIGJhc2VTaW5rLCBHc3RCdWZmZXIqIGJ1 ZgogICAgICAgICBHc3RWaWRlb0ZyYW1lIGRlc3RpbmF0aW9uRnJhbWU7CiAKICAgICAgICAgaWYg KCFnc3RfdmlkZW9fZnJhbWVfbWFwKCZzb3VyY2VGcmFtZSwgJnByaXYtPmluZm8sIGJ1ZmZlciwg R1NUX01BUF9SRUFEKSkgewotICAgICAgICAgICAgZ3N0X3NhbXBsZV91bnJlZihwcml2LT5zYW1w bGUpOwogICAgICAgICAgICAgZ3N0X2J1ZmZlcl91bnJlZihuZXdCdWZmZXIpOwotICAgICAgICAg ICAgcmV0dXJuIEdTVF9GTE9XX0VSUk9SOworICAgICAgICAgICAgcmV0dXJuIG51bGxwdHI7CiAg ICAgICAgIH0KICAgICAgICAgaWYgKCFnc3RfdmlkZW9fZnJhbWVfbWFwKCZkZXN0aW5hdGlvbkZy YW1lLCAmcHJpdi0+aW5mbywgbmV3QnVmZmVyLCBHU1RfTUFQX1dSSVRFKSkgewogICAgICAgICAg ICAgZ3N0X3ZpZGVvX2ZyYW1lX3VubWFwKCZzb3VyY2VGcmFtZSk7CiAgICAgICAgICAgICBnc3Rf YnVmZmVyX3VucmVmKG5ld0J1ZmZlcik7Ci0gICAgICAgICAgICByZXR1cm4gR1NUX0ZMT1dfRVJS T1I7CisgICAgICAgICAgICByZXR1cm4gbnVsbHB0cjsKICAgICAgICAgfQogCiAgICAgICAgIGNv bnN0IGd1aW50OCogc291cmNlID0gc3RhdGljX2Nhc3Q8Z3VpbnQ4Kj4oR1NUX1ZJREVPX0ZSQU1F X1BMQU5FX0RBVEEoJnNvdXJjZUZyYW1lLCAwKSk7CkBAIC0yMDksMjAgKzI0MywxNyBAQCBzdGF0 aWMgR3N0Rmxvd1JldHVybiB3ZWJraXRWaWRlb1NpbmtSZW5kZXIoR3N0QmFzZVNpbmsqIGJhc2VT aW5rLCBHc3RCdWZmZXIqIGJ1ZgogCiAgICAgICAgIGdzdF92aWRlb19mcmFtZV91bm1hcCgmc291 cmNlRnJhbWUpOwogICAgICAgICBnc3RfdmlkZW9fZnJhbWVfdW5tYXAoJmRlc3RpbmF0aW9uRnJh bWUpOwotICAgICAgICBnc3Rfc2FtcGxlX3VucmVmKHByaXYtPnNhbXBsZSk7Ci0gICAgICAgIHBy aXYtPnNhbXBsZSA9IGdzdF9zYW1wbGVfbmV3KG5ld0J1ZmZlciwgcHJpdi0+Y3VycmVudENhcHMs IDAsIDApOworICAgICAgICBzYW1wbGUgPSBhZG9wdEdSZWYoZ3N0X3NhbXBsZV9uZXcobmV3QnVm ZmVyLCBwcml2LT5jdXJyZW50Q2FwcywgbnVsbHB0ciwgbnVsbHB0cikpOwogICAgIH0KICNlbmRp ZgogCi0gICAgLy8gVGhpcyBzaG91bGQgbGlrZWx5IHVzZSBhIGxvd2VyIHByaW9yaXR5LCBidXQg Z2xpYiBjdXJyZW50bHkgc3RhcnZlcwotICAgIC8vIGxvd2VyIHByaW9yaXR5IHNvdXJjZXMuCi0g ICAgLy8gU2VlOiBodHRwczovL2J1Z3ppbGxhLmdub21lLm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjEw ODMwLgotICAgIEdSZWZQdHI8V2ViS2l0VmlkZW9TaW5rPiBwcm90ZWN0b3Ioc2luayk7Ci0gICAg cHJpdi0+dGltZW91dFNvdXJjZS5zY2hlZHVsZSgiW1dlYktpdF0gd2Via2l0VmlkZW9TaW5rVGlt ZW91dENhbGxiYWNrIiwKLSAgICAgICAgc3RkOjpmdW5jdGlvbjx2b2lkKCk+KFtwcm90ZWN0b3Jd IHsgd2Via2l0VmlkZW9TaW5rVGltZW91dENhbGxiYWNrKHByb3RlY3Rvci5nZXQoKSk7IH0pKTsK KyAgICByZXR1cm4gc2FtcGxlOworfQogCi0gICAgZ19jb25kX3dhaXQoJnByaXYtPmRhdGFDb25k aXRpb24sICZwcml2LT5zYW1wbGVNdXRleCk7Ci0gICAgcmV0dXJuIEdTVF9GTE9XX09LOworc3Rh dGljIEdzdEZsb3dSZXR1cm4gd2Via2l0VmlkZW9TaW5rUmVuZGVyKEdzdEJhc2VTaW5rKiBiYXNl U2luaywgR3N0QnVmZmVyKiBidWZmZXIpCit7CisgICAgV2ViS2l0VmlkZW9TaW5rKiBzaW5rID0g V0VCS0lUX1ZJREVPX1NJTksoYmFzZVNpbmspOworICAgIHJldHVybiBzaW5rLT5wcml2LT5zY2hl ZHVsZXIucmVxdWVzdFJlbmRlcihzaW5rLCBidWZmZXIpID8gR1NUX0ZMT1dfT0sgOiBHU1RfRkxP V19FUlJPUjsKIH0KIAogc3RhdGljIHZvaWQgd2Via2l0VmlkZW9TaW5rRmluYWxpemUoR09iamVj dCogb2JqZWN0KQpAQCAtMjMxLDI1ICsyNjIsMTEgQEAgc3RhdGljIHZvaWQgd2Via2l0VmlkZW9T aW5rRmluYWxpemUoR09iamVjdCogb2JqZWN0KQogICAgIEdfT0JKRUNUX0NMQVNTKHBhcmVudF9j bGFzcyktPmZpbmFsaXplKG9iamVjdCk7CiB9CiAKLXN0YXRpYyB2b2lkIHVubG9ja1NhbXBsZU11 dGV4KFdlYktpdFZpZGVvU2lua1ByaXZhdGUqIHByaXYpCi17Ci0gICAgV1RGOjpHTXV0ZXhMb2Nr ZXI8R011dGV4PiBsb2NrKHByaXYtPnNhbXBsZU11dGV4KTsKLQotICAgIGlmIChwcml2LT5zYW1w bGUpIHsKLSAgICAgICAgZ3N0X3NhbXBsZV91bnJlZihwcml2LT5zYW1wbGUpOwotICAgICAgICBw cml2LT5zYW1wbGUgPSAwOwotICAgIH0KLQotICAgIHByaXYtPnVubG9ja2VkID0gdHJ1ZTsKLQot ICAgIGdfY29uZF9zaWduYWwoJnByaXYtPmRhdGFDb25kaXRpb24pOwotfQotCiBzdGF0aWMgZ2Jv b2xlYW4gd2Via2l0VmlkZW9TaW5rVW5sb2NrKEdzdEJhc2VTaW5rKiBiYXNlU2luaykKIHsKLSAg ICBXZWJLaXRWaWRlb1NpbmsqIHNpbmsgPSBXRUJLSVRfVklERU9fU0lOSyhiYXNlU2luayk7Cisg ICAgV2ViS2l0VmlkZW9TaW5rUHJpdmF0ZSogcHJpdiA9IFdFQktJVF9WSURFT19TSU5LKGJhc2VT aW5rKS0+cHJpdjsKIAotICAgIHVubG9ja1NhbXBsZU11dGV4KHNpbmstPnByaXYpOworICAgIHBy aXYtPnNjaGVkdWxlci5zdG9wKCk7CiAKICAgICByZXR1cm4gR1NUX0NBTExfUEFSRU5UX1dJVEhf REVGQVVMVChHU1RfQkFTRV9TSU5LX0NMQVNTLCB1bmxvY2ssIChiYXNlU2luayksIFRSVUUpOwog fQpAQCAtMjU4LDEwICsyNzUsNyBAQCBzdGF0aWMgZ2Jvb2xlYW4gd2Via2l0VmlkZW9TaW5rVW5s b2NrU3RvcChHc3RCYXNlU2luayogYmFzZVNpbmspCiB7CiAgICAgV2ViS2l0VmlkZW9TaW5rUHJp dmF0ZSogcHJpdiA9IFdFQktJVF9WSURFT19TSU5LKGJhc2VTaW5rKS0+cHJpdjsKIAotICAgIHsK LSAgICAgICAgV1RGOjpHTXV0ZXhMb2NrZXI8R011dGV4PiBsb2NrKHByaXYtPnNhbXBsZU11dGV4 KTsKLSAgICAgICAgcHJpdi0+dW5sb2NrZWQgPSBmYWxzZTsKLSAgICB9CisgICAgcHJpdi0+c2No ZWR1bGVyLnN0YXJ0KCk7CiAKICAgICByZXR1cm4gR1NUX0NBTExfUEFSRU5UX1dJVEhfREVGQVVM VChHU1RfQkFTRV9TSU5LX0NMQVNTLCB1bmxvY2tfc3RvcCwgKGJhc2VTaW5rKSwgVFJVRSk7CiB9 CkBAIC0yNzAsMTEgKzI4NCwxMCBAQCBzdGF0aWMgZ2Jvb2xlYW4gd2Via2l0VmlkZW9TaW5rU3Rv cChHc3RCYXNlU2luayogYmFzZVNpbmspCiB7CiAgICAgV2ViS2l0VmlkZW9TaW5rUHJpdmF0ZSog cHJpdiA9IFdFQktJVF9WSURFT19TSU5LKGJhc2VTaW5rKS0+cHJpdjsKIAotICAgIHVubG9ja1Nh bXBsZU11dGV4KHByaXYpOwotCisgICAgcHJpdi0+c2NoZWR1bGVyLnN0b3AoKTsKICAgICBpZiAo cHJpdi0+Y3VycmVudENhcHMpIHsKICAgICAgICAgZ3N0X2NhcHNfdW5yZWYocHJpdi0+Y3VycmVu dENhcHMpOwotICAgICAgICBwcml2LT5jdXJyZW50Q2FwcyA9IDA7CisgICAgICAgIHByaXYtPmN1 cnJlbnRDYXBzID0gbnVsbHB0cjsKICAgICB9CiAKICAgICByZXR1cm4gVFJVRTsKQEAgLTI4NCw4 ICsyOTcsOCBAQCBzdGF0aWMgZ2Jvb2xlYW4gd2Via2l0VmlkZW9TaW5rU3RhcnQoR3N0QmFzZVNp bmsqIGJhc2VTaW5rKQogewogICAgIFdlYktpdFZpZGVvU2lua1ByaXZhdGUqIHByaXYgPSBXRUJL SVRfVklERU9fU0lOSyhiYXNlU2luayktPnByaXY7CiAKLSAgICBXVEY6OkdNdXRleExvY2tlcjxH TXV0ZXg+IGxvY2socHJpdi0+c2FtcGxlTXV0ZXgpOwotICAgIHByaXYtPnVubG9ja2VkID0gZmFs c2U7CisgICAgcHJpdi0+c2NoZWR1bGVyLnN0YXJ0KCk7CisKICAgICByZXR1cm4gVFJVRTsKIH0K IAo=