137793 2014-10-16 15:22:04 -0700 Calling glReadPixels with BGRA format on an NVIDIA machine with an opaque context returns the wrong alpha values. 2014-10-19 00:19:31 -0700 1 1 1 Unclassified WebKit WebGL 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 roger_fong webkit-unassigned bfulgham commit-queue dino jonlee kondapallykalyan noam roger_fong oldest_to_newest 1042218 0 roger_fong 2014-10-16 15:22:04 -0700 When we call readPixels from the WebGLRenderingContext note that we spit out an error if GL_BGRA format is used. However, we for some reason use this format when reading the rendering the results for the purposes of either reading the rendering results into an ImageData or a canvas. This color format seems to fail specifically fail on NVIDIA cards and in particular the alpha channel can be read incorrectly when the alpha is off for the context. However, I will make a blanket change here for all devices and context attribute settings for alpha to be consistent with WebGLRenderingContext::readPixels which does the following: switch (format) { case GraphicsContext3D::ALPHA: case GraphicsContext3D::RGB: case GraphicsContext3D::RGBA: break; default: synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "readPixels", "invalid format"); return; } 1042229 1 239980 roger_fong 2014-10-16 16:05:19 -0700 Created attachment 239980 patch 1042233 2 239980 bfulgham 2014-10-16 16:12:10 -0700 Comment on attachment 239980 patch View in context: https://bugs.webkit.org/attachment.cgi?id=239980&action=review I think this change will break whatever port uses the OpenGLES backend (EFL maybe?). > Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGLCommon.cpp:254 > + ::glReadPixels(0, 0, m_currentWidth, m_currentHeight, GL_RGBA, GL_UNSIGNED_BYTE, pixels); I think this was here to support OpenGLES clients. See GraphicsContext3DOPenGLES.cpp, which looks like GraphicsContext3D::readPixelsAndConvertToBGRAIfNecessary, except that it swaps the R and B pixels. 1042312 3 roger_fong 2014-10-16 23:44:41 -0700 *** Bug 137752 has been marked as a duplicate of this bug. *** 1042313 4 roger_fong 2014-10-16 23:47:10 -0700 Chromium queries in RGBA, not BGRA and swaps if necessary, which is essentially what my patch will do, except only for NVIDIA cards where this is actually an issue. 1042314 5 240001 roger_fong 2014-10-16 23:50:27 -0700 Created attachment 240001 patch 1042405 6 240001 dino 2014-10-17 11:06:27 -0700 Comment on attachment 240001 patch View in context: https://bugs.webkit.org/attachment.cgi?id=240001&action=review > Source/WebCore/ChangeLog:13 > + On an nvidia machine, when the context has alpha turned off, call glReadPixels with RGBA format and then convert to RGBA. NVIDIA 1042409 7 240001 dino 2014-10-17 11:31:54 -0700 Comment on attachment 240001 patch View in context: https://bugs.webkit.org/attachment.cgi?id=240001&action=review > Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGL.cpp:73 > + int totalBytes = width * height * 4; > + for (int i = 0; i < totalBytes; i += 4) > + std::swap(pixels[i], pixels[i + 2]); I wonder if something like vImagePermuteChannels_ARGB8888 would do this faster. 1042412 8 240001 dino 2014-10-17 11:38:42 -0700 Comment on attachment 240001 patch View in context: https://bugs.webkit.org/attachment.cgi?id=240001&action=review > Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGL.cpp:72 > + ::glReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, pixels); > + int totalBytes = width * height * 4; > + for (int i = 0; i < totalBytes; i += 4) e.g. vImage_Buffer src; src.height = height; src.width = width; src.rowBytes = srcBytesPerRow; src.data = srcRows; vImage_Buffer dest; dest.height = height; dest.width = width; dest.rowBytes = destBytesPerRow; dest.data = destRows; // Swap pixel channels from BGRA to RGBA. const uint8_t map[4] = { 2, 1, 0, 3 }; vImagePermuteChannels_ARGB8888(&src, &dest, map, kvImageNoFlags); 1042413 9 240001 dino 2014-10-17 11:39:15 -0700 Comment on attachment 240001 patch View in context: https://bugs.webkit.org/attachment.cgi?id=240001&action=review >> Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGL.cpp:72 >> + for (int i = 0; i < totalBytes; i += 4) > > e.g. > vImage_Buffer src; > src.height = height; > src.width = width; > src.rowBytes = srcBytesPerRow; > src.data = srcRows; > > vImage_Buffer dest; > dest.height = height; > dest.width = width; > dest.rowBytes = destBytesPerRow; > dest.data = destRows; > > // Swap pixel channels from BGRA to RGBA. > const uint8_t map[4] = { 2, 1, 0, 3 }; > vImagePermuteChannels_ARGB8888(&src, &dest, map, kvImageNoFlags); Except you want the other way around :) 1042437 10 roger_fong 2014-10-17 13:00:44 -0700 I'll try running instruments on a test page with a) no swapping at all b) the std::swap c) the vImagePermuteChannels_ARGB8888 1042524 11 roger_fong 2014-10-17 16:43:08 -0700 a) No reason to run this test really...all readPixelsAndConvertToBGRAIfNecessary does on mac is call glReadPixels, so the times are the same. b) Running Time Self Symbol Name 5012.0ms 3.8% 445.0 readPixelsAndConvertToBGRAIfNecessary 4562.0ms 3.5% 1.0 glReadPixels c) Running Time Self Symbol Name 5006.0ms 4.8% 1.0 readPixelsAndConvertToBGRAIfNecessary 4833.0ms 4.7% 0.0 glReadPixels So it looks like the vaccelerator stuff is definitely faster, though I guess we already knew that to be the case. 1042534 12 240053 roger_fong 2014-10-17 17:08:02 -0700 Created attachment 240053 patch 1042535 13 roger_fong 2014-10-17 17:13:42 -0700 (In reply to comment #11) > a) No reason to run this test really...all > readPixelsAndConvertToBGRAIfNecessary does on mac is call glReadPixels, so > the times are the same. > > b) > Running Time Self Symbol Name > 5012.0ms 3.8% 445.0 readPixelsAndConvertToBGRAIfNecessary > > 4562.0ms 3.5% 1.0 glReadPixels > > c) > Running Time Self Symbol Name > 5006.0ms 4.8% 1.0 readPixelsAndConvertToBGRAIfNecessary > > 4833.0ms 4.7% 0.0 glReadPixels > > So it looks like the vaccelerator stuff is definitely faster, though I guess > we already knew that to be the case. What we're comparing is the differences between the two function calls (which is the time it takes to swap the 1st and 3rd channels). Using accelerator stuff is about 30% better. 1042536 14 240053 dino 2014-10-17 17:14:34 -0700 Comment on attachment 240053 patch View in context: https://bugs.webkit.org/attachment.cgi?id=240053&action=review > Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGL.cpp:89 > + // NVIDIA drivers have a bug where calling readPixels in BGRA can return the wrong values for the alpha channel when the alpha is off for the context. > + if (!m_attrs.alpha && getExtensions()->isNVIDIA()) { > + ::glReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels); > + vImage_Buffer src; > + src.height = height; > + src.width = width; > + src.rowBytes = width*4; > + src.data = pixels; > + > + vImage_Buffer dest; > + dest.height = height; > + dest.width = width; > + dest.rowBytes = width*4; > + dest.data = pixels; > + > + // Swap pixel channels from BGRA to RGBA. > + const uint8_t map[4] = { 2, 1, 0, 3 }; > + vImagePermuteChannels_ARGB8888(&src, &dest, map, kvImageNoFlags); Won't you need the USE(ACCELERATE) around this too? Other ports won't work. 1042566 15 240053 thorton 2014-10-17 22:27:02 -0700 Comment on attachment 240053 patch View in context: https://bugs.webkit.org/attachment.cgi?id=240053&action=review > Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGL.cpp:72 > + // NVIDIA drivers have a bug where calling readPixels in BGRA can return the wrong values for the alpha channel when the alpha is off for the context. Is this true for all NVIDIA drivers, historically? Is this likely to change? Should we be detecting the wrongness somehow instead of just flipping things around like this? > Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGL.cpp:78 > + src.rowBytes = width*4; Spaces around the star, please. > Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGL.cpp:84 > + dest.rowBytes = width*4; Ditto. 1042669 16 roger_fong 2014-10-18 23:40:02 -0700 (In reply to comment #15) > Comment on attachment 240053 [details] > patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=240053&action=review > > > Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGL.cpp:72 > > + // NVIDIA drivers have a bug where calling readPixels in BGRA can return the wrong values for the alpha channel when the alpha is off for the context. > > Is this true for all NVIDIA drivers, historically? Is this likely to change? > Should we be detecting the wrongness somehow instead of just flipping things > around like this? We'd then have to make two queries to glReadPixels then which seems unfortunate. I've tested on 3 devices, dating back to the 2009 macbook pro card. > > > Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGL.cpp:78 > > + src.rowBytes = width*4; > > Spaces around the star, please. > > > Source/WebCore/platform/graphics/opengl/GraphicsContext3DOpenGL.cpp:84 > > + dest.rowBytes = width*4; > > Ditto. Whoops missed those, I'll add those in. 1042674 17 roger_fong 2014-10-19 00:19:31 -0700 http://trac.webkit.org/changeset/174855 http://trac.webkit.org/changeset/174867 239980 2014-10-16 16:05:19 -0700 2014-10-16 23:50:27 -0700 patch patch.patch text/plain 4247 roger_fong SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDE3NDc5NikKKysrIFNvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDIxIEBACisyMDE0LTEwLTE2ICBSb2dlciBG b25nICA8cm9nZXJfZm9uZ0BhcHBsZS5jb20+CisKKyAgICAgICAgRG9uJ3QgdXNlIEJHUkEgZm9y bWF0IHdoZW4gcmVhZGluZyByZW5kZXJpbmcgcmVzdWx0cy4KKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEzNzc5My4KKyAgICAgICAgPHJkYXI6Ly9wcm9i bGVtLzE1NDA4MTMzPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIFRoaXMgZml4ZXMgY29uZm9ybWFuY2UgdGVzdCBjb250ZXh0L2NvbnRleHQtYXR0cmli dXRlLXByZXNlcnZlLWRyYXdpbmctYnVmZmVyLmh0bWwuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9n cmFwaGljcy9HcmFwaGljc0NvbnRleHQzRC5oOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNz L29wZW5nbC9HcmFwaGljc0NvbnRleHQzRE9wZW5HTC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpH cmFwaGljc0NvbnRleHQzRDo6cmVhZFBpeGVsc0FuZENvbnZlcnRUb0JHUkFJZk5lY2Vzc2FyeSk6 IERlbGV0ZWQuCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mvb3BlbmdsL0dyYXBoaWNzQ29u dGV4dDNET3BlbkdMQ29tbW9uLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4 dDNEOjpwYWludFJlbmRlcmluZ1Jlc3VsdHNUb0NhbnZhcyk6IE5lZWQgdG8gY29udmVydCB0byBS R0JBIGZvcm1hdC4KKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDNEOjpwYWludFJl bmRlcmluZ1Jlc3VsdHNUb0ltYWdlRGF0YSk6IE5vIG5lZWQgdG8gY29udmVydCB0byBSR0JBIGZv cm1hdCBhbnltb3JlLgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0Q6OnJlYWRS ZW5kZXJpbmdSZXN1bHRzKTogUmVhZCBwaXhlbHMgdXNpbmcgUkdCQSBmb3JtYXQgaW5zdGVhZCBv ZiBCR1JBIGZvcm1hdC4KKwogMjAxNC0xMC0xNiAgQ29tbWl0IFF1ZXVlICA8Y29tbWl0LXF1ZXVl QHdlYmtpdC5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjE3NDc0NC4K SW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dDNE LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhp Y3NDb250ZXh0M0QuaAkocmV2aXNpb24gMTc0Nzk1KQorKysgU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0M0QuaAkod29ya2luZyBjb3B5KQpAQCAtOTg4LDcg Kzk4OCw2IEBAIHByaXZhdGU6CiAgICAgLy8gUmVhZCByZW5kZXJpbmcgcmVzdWx0cyBpbnRvIGEg cGl4ZWwgYXJyYXkgd2l0aCB0aGUgc2FtZSBmb3JtYXQgYXMgdGhlCiAgICAgLy8gYmFja2J1ZmZl ci4KICAgICB2b2lkIHJlYWRSZW5kZXJpbmdSZXN1bHRzKHVuc2lnbmVkIGNoYXIqIHBpeGVscywg aW50IHBpeGVsc1NpemUpOwotICAgIHZvaWQgcmVhZFBpeGVsc0FuZENvbnZlcnRUb0JHUkFJZk5l Y2Vzc2FyeShpbnQgeCwgaW50IHksIGludCB3aWR0aCwgaW50IGhlaWdodCwgdW5zaWduZWQgY2hh ciogcGl4ZWxzKTsKIAogI2lmIFBMQVRGT1JNKElPUykKICAgICBib29sIHNldFJlbmRlcmJ1ZmZl clN0b3JhZ2VGcm9tRHJhd2FibGUoR0MzRHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0KTsK SW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL29wZW5nbC9HcmFwaGljc0Nv bnRleHQzRE9wZW5HTC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3Mvb3BlbmdsL0dyYXBoaWNzQ29udGV4dDNET3BlbkdMLmNwcAkocmV2aXNpb24gMTc0 Nzk1KQorKysgU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvb3BlbmdsL0dyYXBoaWNz Q29udGV4dDNET3BlbkdMLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNjMsMTEgKzYzLDYgQEAgdm9p ZCBHcmFwaGljc0NvbnRleHQzRDo6cmVsZWFzZVNoYWRlckNvbQogICAgIG5vdEltcGxlbWVudGVk KCk7CiB9CiAKLXZvaWQgR3JhcGhpY3NDb250ZXh0M0Q6OnJlYWRQaXhlbHNBbmRDb252ZXJ0VG9C R1JBSWZOZWNlc3NhcnkoaW50IHgsIGludCB5LCBpbnQgd2lkdGgsIGludCBoZWlnaHQsIHVuc2ln bmVkIGNoYXIqIHBpeGVscykKLXsKLSAgICA6OmdsUmVhZFBpeGVscyh4LCB5LCB3aWR0aCwgaGVp Z2h0LCBHTF9CR1JBLCBHTF9VTlNJR05FRF9JTlRfOF84XzhfOF9SRVYsIHBpeGVscyk7Ci19Ci0K IHZvaWQgR3JhcGhpY3NDb250ZXh0M0Q6OnZhbGlkYXRlQXR0cmlidXRlcygpCiB7CiAgICAgdmFs aWRhdGVEZXB0aFN0ZW5jaWwoIkdMX0VYVF9wYWNrZWRfZGVwdGhfc3RlbmNpbCIpOwpJbmRleDog U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvb3BlbmdsL0dyYXBoaWNzQ29udGV4dDNE T3BlbkdMQ29tbW9uLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9vcGVuZ2wvR3JhcGhpY3NDb250ZXh0M0RPcGVuR0xDb21tb24uY3BwCShyZXZpc2lv biAxNzQ3OTUpCisrKyBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9vcGVuZ2wvR3Jh cGhpY3NDb250ZXh0M0RPcGVuR0xDb21tb24uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xNTQsOCAr MTU0LDEwIEBAIHZvaWQgR3JhcGhpY3NDb250ZXh0M0Q6OnBhaW50UmVuZGVyaW5nUmUKIAogICAg IHJlYWRSZW5kZXJpbmdSZXN1bHRzKHBpeGVscy5nZXQoKSwgdG90YWxCeXRlcyk7CiAKLSAgICBp ZiAoIW1fYXR0cnMucHJlbXVsdGlwbGllZEFscGhhKSB7Ci0gICAgICAgIGZvciAoaW50IGkgPSAw OyBpIDwgdG90YWxCeXRlczsgaSArPSA0KSB7CisgICAgZm9yIChpbnQgaSA9IDA7IGkgPCB0b3Rh bEJ5dGVzOyBpICs9IDQpIHsKKyAgICAgICAgLy8gQ29udmVydCB0byBCR1JBLgorICAgICAgICBz dGQ6OnN3YXAocGl4ZWxzW2ldLCBwaXhlbHNbaSArIDJdKTsKKyAgICAgICAgaWYgKCFtX2F0dHJz LnByZW11bHRpcGxpZWRBbHBoYSkgewogICAgICAgICAgICAgLy8gUHJlbXVsdGlwbHkgYWxwaGEu CiAgICAgICAgICAgICBwaXhlbHNbaSArIDBdID0gc3RkOjptaW4oMjU1LCBwaXhlbHNbaSArIDBd ICogcGl4ZWxzW2kgKyAzXSAvIDI1NSk7CiAgICAgICAgICAgICBwaXhlbHNbaSArIDFdID0gc3Rk OjptaW4oMjU1LCBwaXhlbHNbaSArIDFdICogcGl4ZWxzW2kgKyAzXSAvIDI1NSk7CkBAIC0xOTUs MTAgKzE5Nyw2IEBAIFBhc3NSZWZQdHI8SW1hZ2VEYXRhPiBHcmFwaGljc0NvbnRleHQzRDoKIAog ICAgIHJlYWRSZW5kZXJpbmdSZXN1bHRzKHBpeGVscywgdG90YWxCeXRlcyk7CiAKLSAgICAvLyBD b252ZXJ0IHRvIFJHQkEuCi0gICAgZm9yIChpbnQgaSA9IDA7IGkgPCB0b3RhbEJ5dGVzOyBpICs9 IDQpCi0gICAgICAgIHN0ZDo6c3dhcChwaXhlbHNbaV0sIHBpeGVsc1tpICsgMl0pOwotCiAgICAg cmV0dXJuIGltYWdlRGF0YS5yZWxlYXNlKCk7CiB9CiAKQEAgLTI1Myw3ICsyNTEsNyBAQCB2b2lk IEdyYXBoaWNzQ29udGV4dDNEOjpyZWFkUmVuZGVyaW5nUmVzCiAgICAgICAgIG11c3RSZXN0b3Jl UGFja0FsaWdubWVudCA9IHRydWU7CiAgICAgfQogCi0gICAgcmVhZFBpeGVsc0FuZENvbnZlcnRU b0JHUkFJZk5lY2Vzc2FyeSgwLCAwLCBtX2N1cnJlbnRXaWR0aCwgbV9jdXJyZW50SGVpZ2h0LCBw aXhlbHMpOworICAgIDo6Z2xSZWFkUGl4ZWxzKDAsIDAsIG1fY3VycmVudFdpZHRoLCBtX2N1cnJl bnRIZWlnaHQsIEdMX1JHQkEsIEdMX1VOU0lHTkVEX0JZVEUsIHBpeGVscyk7CiAKICAgICBpZiAo bXVzdFJlc3RvcmVQYWNrQWxpZ25tZW50KQogICAgICAgICA6OmdsUGl4ZWxTdG9yZWkoR0xfUEFD S19BTElHTk1FTlQsIHBhY2tBbGlnbm1lbnQpOwo= 240001 2014-10-16 23:50:27 -0700 2014-10-17 17:08:02 -0700 patch patch.patch text/plain 2184 roger_fong SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDE3NDgwMCkKKysrIFNvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE3IEBACisyMDE0LTEwLTE2ICBSb2dlciBG b25nICA8cm9nZXJfZm9uZ0BhcHBsZS5jb20+CisKKyAgICAgICAgQ2FsbGluZyBnbFJlYWRQaXhl bHMgd2l0aCBCR1JBIGZvcm1hdCBvbiBhbiBOVklESUEgbWFjaGluZSB3aXRoIGFuIG9wYXF1ZSBj b250ZXh0IHJldHVybnMgdGhlIHdyb25nIGFscGhhIHZhbHVlcy4KKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEzNzc5My4KKyAgICAgICAgPHJkYXI6Ly9w cm9ibGVtLzE1NDA4MTMzPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIFRoaXMgZml4ZXMgY29uZm9ybWFuY2UgdGVzdCBjb250ZXh0L2NvbnRleHQtYXR0 cmlidXRlLXByZXNlcnZlLWRyYXdpbmctYnVmZmVyLmh0bWwuCisKKyAgICAgICAgKiBwbGF0Zm9y bS9ncmFwaGljcy9vcGVuZ2wvR3JhcGhpY3NDb250ZXh0M0RPcGVuR0wuY3BwOgorICAgICAgICAo V2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0Q6OnJlYWRQaXhlbHNBbmRDb252ZXJ0VG9CR1JBSWZO ZWNlc3NhcnkpOgorICAgICAgICBPbiBhbiBudmlkaWEgbWFjaGluZSwgd2hlbiB0aGUgY29udGV4 dCBoYXMgYWxwaGEgdHVybmVkIG9mZiwgY2FsbCBnbFJlYWRQaXhlbHMgd2l0aCBSR0JBIGZvcm1h dCBhbmQgdGhlbiBjb252ZXJ0IHRvIFJHQkEuCisKIDIwMTQtMTAtMTYgIENvbW1pdCBRdWV1ZSAg PGNvbW1pdC1xdWV1ZUB3ZWJraXQub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcg b3V0IHIxNzQ3NDQuCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9vcGVu Z2wvR3JhcGhpY3NDb250ZXh0M0RPcGVuR0wuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL29wZW5nbC9HcmFwaGljc0NvbnRleHQzRE9wZW5HTC5jcHAJ KHJldmlzaW9uIDE3NDc5NSkKKysrIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL29w ZW5nbC9HcmFwaGljc0NvbnRleHQzRE9wZW5HTC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTY1LDcg KzY1LDE0IEBAIHZvaWQgR3JhcGhpY3NDb250ZXh0M0Q6OnJlbGVhc2VTaGFkZXJDb20KIAogdm9p ZCBHcmFwaGljc0NvbnRleHQzRDo6cmVhZFBpeGVsc0FuZENvbnZlcnRUb0JHUkFJZk5lY2Vzc2Fy eShpbnQgeCwgaW50IHksIGludCB3aWR0aCwgaW50IGhlaWdodCwgdW5zaWduZWQgY2hhciogcGl4 ZWxzKQogewotICAgIDo6Z2xSZWFkUGl4ZWxzKHgsIHksIHdpZHRoLCBoZWlnaHQsIEdMX0JHUkEs IEdMX1VOU0lHTkVEX0lOVF84XzhfOF84X1JFViwgcGl4ZWxzKTsKKyAgICAvLyBOVklESUEgZHJp dmVycyBoYXZlIGEgYnVnIHdoZXJlIGNhbGxpbmcgcmVhZFBpeGVscyBpbiBCR1JBIGNhbiByZXR1 cm4gdGhlIHdyb25nIHZhbHVlcyBmb3IgdGhlIGFscGhhIGNoYW5uZWwgd2hlbiB0aGUgYWxwaGEg aXMgb2ZmIGZvciB0aGUgY29udGV4dC4KKyAgICBpZiAoIW1fYXR0cnMuYWxwaGEgJiYgZ2V0RXh0 ZW5zaW9ucygpLT5pc05WSURJQSgpKSB7CisgICAgICAgIDo6Z2xSZWFkUGl4ZWxzKHgsIHksIHdp ZHRoLCBoZWlnaHQsIEdMX1JHQkEsIEdMX1VOU0lHTkVEX0lOVF84XzhfOF84X1JFViwgcGl4ZWxz KTsKKyAgICAgICAgaW50IHRvdGFsQnl0ZXMgPSB3aWR0aCAqIGhlaWdodCAqIDQ7CisgICAgICAg IGZvciAoaW50IGkgPSAwOyBpIDwgdG90YWxCeXRlczsgaSArPSA0KQorICAgICAgICAgICAgc3Rk Ojpzd2FwKHBpeGVsc1tpXSwgcGl4ZWxzW2kgKyAyXSk7CisgICAgfSBlbHNlCisgICAgICAgIDo6 Z2xSZWFkUGl4ZWxzKHgsIHksIHdpZHRoLCBoZWlnaHQsIEdMX0JHUkEsIEdMX1VOU0lHTkVEX0lO VF84XzhfOF84X1JFViwgcGl4ZWxzKTsKIH0KIAogdm9pZCBHcmFwaGljc0NvbnRleHQzRDo6dmFs aWRhdGVBdHRyaWJ1dGVzKCkK 240053 2014-10-17 17:08:02 -0700 2014-10-17 17:14:34 -0700 patch patch.patch text/plain 2732 roger_fong SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDE3NDgwMCkKKysrIFNvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE3IEBACisyMDE0LTEwLTE2ICBSb2dlciBG b25nICA8cm9nZXJfZm9uZ0BhcHBsZS5jb20+CisKKyAgICAgICAgQ2FsbGluZyBnbFJlYWRQaXhl bHMgd2l0aCBCR1JBIGZvcm1hdCBvbiBhbiBOVklESUEgbWFjaGluZSB3aXRoIGFuIG9wYXF1ZSBj b250ZXh0IHJldHVybnMgdGhlIHdyb25nIGFscGhhIHZhbHVlcy4KKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEzNzc5My4KKyAgICAgICAgPHJkYXI6Ly9w cm9ibGVtLzE1NDA4MTMzPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIFRoaXMgZml4ZXMgY29uZm9ybWFuY2UgdGVzdCBjb250ZXh0L2NvbnRleHQtYXR0 cmlidXRlLXByZXNlcnZlLWRyYXdpbmctYnVmZmVyLmh0bWwuCisKKyAgICAgICAgKiBwbGF0Zm9y bS9ncmFwaGljcy9vcGVuZ2wvR3JhcGhpY3NDb250ZXh0M0RPcGVuR0wuY3BwOgorICAgICAgICAo V2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0Q6OnJlYWRQaXhlbHNBbmRDb252ZXJ0VG9CR1JBSWZO ZWNlc3NhcnkpOgorICAgICAgICBPbiBhbiBOVklESUEgbWFjaGluZSwgd2hlbiB0aGUgY29udGV4 dCBoYXMgYWxwaGEgdHVybmVkIG9mZiwgY2FsbCBnbFJlYWRQaXhlbHMgd2l0aCBSR0JBIGZvcm1h dCBhbmQgdGhlbiBjb252ZXJ0IHRvIFJHQkEuCisKIDIwMTQtMTAtMTYgIENvbW1pdCBRdWV1ZSAg PGNvbW1pdC1xdWV1ZUB3ZWJraXQub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcg b3V0IHIxNzQ3NDQuCkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9vcGVu Z2wvR3JhcGhpY3NDb250ZXh0M0RPcGVuR0wuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL29wZW5nbC9HcmFwaGljc0NvbnRleHQzRE9wZW5HTC5jcHAJ KHJldmlzaW9uIDE3NDc5NSkKKysrIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL29w ZW5nbC9HcmFwaGljc0NvbnRleHQzRE9wZW5HTC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTQ0LDYg KzQ0LDEwIEBACiAjaW5jbHVkZSA8d3RmL01haW5UaHJlYWQuaD4KICNpbmNsdWRlIDx3dGYvdGV4 dC9DU3RyaW5nLmg+CiAKKyNpZiBVU0UoQUNDRUxFUkFURSkKKyNpbmNsdWRlIDxBY2NlbGVyYXRl L0FjY2VsZXJhdGUuaD4KKyNlbmRpZgorCiAjaWYgUExBVEZPUk0oSU9TKQogI2ltcG9ydCA8T3Bl bkdMRVMvRVMyL2dsZXh0Lmg+CiAvLyBGcm9tIDxPcGVuR0xFUy9nbGV4dC5oPgpAQCAtNjUsNyAr NjksMjYgQEAgdm9pZCBHcmFwaGljc0NvbnRleHQzRDo6cmVsZWFzZVNoYWRlckNvbQogCiB2b2lk IEdyYXBoaWNzQ29udGV4dDNEOjpyZWFkUGl4ZWxzQW5kQ29udmVydFRvQkdSQUlmTmVjZXNzYXJ5 KGludCB4LCBpbnQgeSwgaW50IHdpZHRoLCBpbnQgaGVpZ2h0LCB1bnNpZ25lZCBjaGFyKiBwaXhl bHMpCiB7Ci0gICAgOjpnbFJlYWRQaXhlbHMoeCwgeSwgd2lkdGgsIGhlaWdodCwgR0xfQkdSQSwg R0xfVU5TSUdORURfSU5UXzhfOF84XzhfUkVWLCBwaXhlbHMpOworICAgIC8vIE5WSURJQSBkcml2 ZXJzIGhhdmUgYSBidWcgd2hlcmUgY2FsbGluZyByZWFkUGl4ZWxzIGluIEJHUkEgY2FuIHJldHVy biB0aGUgd3JvbmcgdmFsdWVzIGZvciB0aGUgYWxwaGEgY2hhbm5lbCB3aGVuIHRoZSBhbHBoYSBp cyBvZmYgZm9yIHRoZSBjb250ZXh0LgorICAgIGlmICghbV9hdHRycy5hbHBoYSAmJiBnZXRFeHRl bnNpb25zKCktPmlzTlZJRElBKCkpIHsKKyAgICAgICAgOjpnbFJlYWRQaXhlbHMoeCwgeSwgd2lk dGgsIGhlaWdodCwgR0xfUkdCQSwgR0xfVU5TSUdORURfQllURSwgcGl4ZWxzKTsKKyAgICAgICAg dkltYWdlX0J1ZmZlciBzcmM7CisgICAgICAgIHNyYy5oZWlnaHQgPSBoZWlnaHQ7CisgICAgICAg IHNyYy53aWR0aCA9IHdpZHRoOworICAgICAgICBzcmMucm93Qnl0ZXMgPSB3aWR0aCo0OworICAg ICAgICBzcmMuZGF0YSA9IHBpeGVsczsKKworICAgICAgICB2SW1hZ2VfQnVmZmVyIGRlc3Q7Cisg ICAgICAgIGRlc3QuaGVpZ2h0ID0gaGVpZ2h0OworICAgICAgICBkZXN0LndpZHRoID0gd2lkdGg7 CisgICAgICAgIGRlc3Qucm93Qnl0ZXMgPSB3aWR0aCo0OworICAgICAgICBkZXN0LmRhdGEgPSBw aXhlbHM7CisKKyAgICAgICAgLy8gU3dhcCBwaXhlbCBjaGFubmVscyBmcm9tIEJHUkEgdG8gUkdC QS4KKyAgICAgICAgY29uc3QgdWludDhfdCBtYXBbNF0gPSB7IDIsIDEsIDAsIDMgfTsKKyAgICAg ICAgdkltYWdlUGVybXV0ZUNoYW5uZWxzX0FSR0I4ODg4KCZzcmMsICZkZXN0LCBtYXAsIGt2SW1h Z2VOb0ZsYWdzKTsKKyAgICB9IGVsc2UKKyAgICAgICAgOjpnbFJlYWRQaXhlbHMoeCwgeSwgd2lk dGgsIGhlaWdodCwgR0xfQkdSQSwgR0xfVU5TSUdORURfSU5UXzhfOF84XzhfUkVWLCBwaXhlbHMp OwogfQogCiB2b2lkIEdyYXBoaWNzQ29udGV4dDNEOjp2YWxpZGF0ZUF0dHJpYnV0ZXMoKQo=