libgui: Split SurfaceTexture tests into more files
Extract the many different test fixtures and suites in SurfaceTexture_test.cpp
into separate files. No real functional changes, just tweaking headers to keep
things building (and adding a few copyright headers I forgot last time).
Change-Id: Id801bd5d617f0cc61d22508fb9b71b41694bdecf
diff --git a/libs/gui/tests/Android.mk b/libs/gui/tests/Android.mk
index 50c99ee..db24065 100644
--- a/libs/gui/tests/Android.mk
+++ b/libs/gui/tests/Android.mk
@@ -9,11 +9,18 @@
LOCAL_SRC_FILES := \
BufferQueue_test.cpp \
CpuConsumer_test.cpp \
+ FillBuffer.cpp \
GLTest.cpp \
IGraphicBufferProducer_test.cpp \
+ MultiTextureConsumer_test.cpp \
SurfaceTextureClient_test.cpp \
- SurfaceTexture_test.cpp \
+ SurfaceTextureFBO_test.cpp \
+ SurfaceTextureGLThreadToGL_test.cpp \
+ SurfaceTextureGLToGL_test.cpp \
+ SurfaceTextureGL_test.cpp \
+ SurfaceTextureMultiContextGL_test.cpp \
Surface_test.cpp \
+ TextureRenderer.cpp \
LOCAL_SHARED_LIBRARIES := \
libEGL \
diff --git a/libs/gui/tests/DisconnectWaiter.h b/libs/gui/tests/DisconnectWaiter.h
new file mode 100644
index 0000000..3a30a19
--- /dev/null
+++ b/libs/gui/tests/DisconnectWaiter.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_DISCONNECT_WAITER_H
+#define ANDROID_DISCONNECT_WAITER_H
+
+#include <gui/IConsumerListener.h>
+
+#include <utils/Condition.h>
+#include <utils/Mutex.h>
+
+namespace android {
+
+// Note that GLConsumer will lose the notifications
+// onBuffersReleased and onFrameAvailable as there is currently
+// no way to forward the events. This DisconnectWaiter will not let the
+// disconnect finish until finishDisconnect() is called. It will
+// also block until a disconnect is called
+class DisconnectWaiter : public BnConsumerListener {
+public:
+ DisconnectWaiter () :
+ mWaitForDisconnect(false),
+ mPendingFrames(0) {
+ }
+
+ void waitForFrame() {
+ Mutex::Autolock lock(mMutex);
+ while (mPendingFrames == 0) {
+ mFrameCondition.wait(mMutex);
+ }
+ mPendingFrames--;
+ }
+
+ virtual void onFrameAvailable() {
+ Mutex::Autolock lock(mMutex);
+ mPendingFrames++;
+ mFrameCondition.signal();
+ }
+
+ virtual void onBuffersReleased() {
+ Mutex::Autolock lock(mMutex);
+ while (!mWaitForDisconnect) {
+ mDisconnectCondition.wait(mMutex);
+ }
+ }
+
+ void finishDisconnect() {
+ Mutex::Autolock lock(mMutex);
+ mWaitForDisconnect = true;
+ mDisconnectCondition.signal();
+ }
+
+private:
+ Mutex mMutex;
+
+ bool mWaitForDisconnect;
+ Condition mDisconnectCondition;
+
+ int mPendingFrames;
+ Condition mFrameCondition;
+};
+
+} // namespace android
+
+#endif
diff --git a/libs/gui/tests/FillBuffer.cpp b/libs/gui/tests/FillBuffer.cpp
new file mode 100644
index 0000000..079962c
--- /dev/null
+++ b/libs/gui/tests/FillBuffer.cpp
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "FillBuffer.h"
+
+#include <ui/GraphicBuffer.h>
+
+#include <gtest/gtest.h>
+
+namespace android {
+
+void fillYV12Buffer(uint8_t* buf, int w, int h, int stride) {
+ const int blockWidth = w > 16 ? w / 16 : 1;
+ const int blockHeight = h > 16 ? h / 16 : 1;
+ const int yuvTexOffsetY = 0;
+ int yuvTexStrideY = stride;
+ int yuvTexOffsetV = yuvTexStrideY * h;
+ int yuvTexStrideV = (yuvTexStrideY/2 + 0xf) & ~0xf;
+ int yuvTexOffsetU = yuvTexOffsetV + yuvTexStrideV * h/2;
+ int yuvTexStrideU = yuvTexStrideV;
+ for (int x = 0; x < w; x++) {
+ for (int y = 0; y < h; y++) {
+ int parityX = (x / blockWidth) & 1;
+ int parityY = (y / blockHeight) & 1;
+ unsigned char intensity = (parityX ^ parityY) ? 63 : 191;
+ buf[yuvTexOffsetY + (y * yuvTexStrideY) + x] = intensity;
+ if (x < w / 2 && y < h / 2) {
+ buf[yuvTexOffsetU + (y * yuvTexStrideU) + x] = intensity;
+ if (x * 2 < w / 2 && y * 2 < h / 2) {
+ buf[yuvTexOffsetV + (y*2 * yuvTexStrideV) + x*2 + 0] =
+ buf[yuvTexOffsetV + (y*2 * yuvTexStrideV) + x*2 + 1] =
+ buf[yuvTexOffsetV + ((y*2+1) * yuvTexStrideV) + x*2 + 0] =
+ buf[yuvTexOffsetV + ((y*2+1) * yuvTexStrideV) + x*2 + 1] =
+ intensity;
+ }
+ }
+ }
+ }
+}
+
+void fillYV12BufferRect(uint8_t* buf, int w, int h, int stride,
+ const android_native_rect_t& rect) {
+ const int yuvTexOffsetY = 0;
+ int yuvTexStrideY = stride;
+ int yuvTexOffsetV = yuvTexStrideY * h;
+ int yuvTexStrideV = (yuvTexStrideY/2 + 0xf) & ~0xf;
+ int yuvTexOffsetU = yuvTexOffsetV + yuvTexStrideV * h/2;
+ int yuvTexStrideU = yuvTexStrideV;
+ for (int x = 0; x < w; x++) {
+ for (int y = 0; y < h; y++) {
+ bool inside = rect.left <= x && x < rect.right &&
+ rect.top <= y && y < rect.bottom;
+ buf[yuvTexOffsetY + (y * yuvTexStrideY) + x] = inside ? 240 : 64;
+ if (x < w / 2 && y < h / 2) {
+ bool inside = rect.left <= 2*x && 2*x < rect.right &&
+ rect.top <= 2*y && 2*y < rect.bottom;
+ buf[yuvTexOffsetU + (y * yuvTexStrideU) + x] = 16;
+ buf[yuvTexOffsetV + (y * yuvTexStrideV) + x] =
+ inside ? 16 : 255;
+ }
+ }
+ }
+}
+
+void fillRGBA8Buffer(uint8_t* buf, int w, int h, int stride) {
+ const size_t PIXEL_SIZE = 4;
+ for (int x = 0; x < w; x++) {
+ for (int y = 0; y < h; y++) {
+ off_t offset = (y * stride + x) * PIXEL_SIZE;
+ for (int c = 0; c < 4; c++) {
+ int parityX = (x / (1 << (c+2))) & 1;
+ int parityY = (y / (1 << (c+2))) & 1;
+ buf[offset + c] = (parityX ^ parityY) ? 231 : 35;
+ }
+ }
+ }
+}
+
+void produceOneRGBA8Frame(const sp<ANativeWindow>& anw) {
+ android_native_buffer_t* anb;
+ ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(),
+ &anb));
+ ASSERT_TRUE(anb != NULL);
+
+ sp<GraphicBuffer> buf(new GraphicBuffer(anb, false));
+
+ uint8_t* img = NULL;
+ ASSERT_EQ(NO_ERROR, buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN,
+ (void**)(&img)));
+ fillRGBA8Buffer(img, buf->getWidth(), buf->getHeight(), buf->getStride());
+ ASSERT_EQ(NO_ERROR, buf->unlock());
+ ASSERT_EQ(NO_ERROR, anw->queueBuffer(anw.get(), buf->getNativeBuffer(),
+ -1));
+}
+} // namespace android
diff --git a/libs/gui/tests/FillBuffer.h b/libs/gui/tests/FillBuffer.h
new file mode 100644
index 0000000..b584179
--- /dev/null
+++ b/libs/gui/tests/FillBuffer.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_FILL_BUFFER_H
+#define ANDROID_FILL_BUFFER_H
+
+#include <system/window.h>
+#include <utils/StrongPointer.h>
+
+namespace android {
+
+// Fill a YV12 buffer with a multi-colored checkerboard pattern
+void fillYV12Buffer(uint8_t* buf, int w, int h, int stride);
+
+// Fill a YV12 buffer with red outside a given rectangle and green inside it.
+void fillYV12BufferRect(uint8_t* buf, int w, int h, int stride,
+ const android_native_rect_t& rect);
+
+void fillRGBA8Buffer(uint8_t* buf, int w, int h, int stride);
+
+// Produce a single RGBA8 frame by filling a buffer with a checkerboard pattern
+// using the CPU. This assumes that the ANativeWindow is already configured to
+// allow this to be done (e.g. the format is set to RGBA8).
+//
+// Calls to this function should be wrapped in an ASSERT_NO_FATAL_FAILURE().
+void produceOneRGBA8Frame(const sp<ANativeWindow>& anw);
+
+} // namespace android
+
+#endif
diff --git a/libs/gui/tests/FrameWaiter.h b/libs/gui/tests/FrameWaiter.h
new file mode 100644
index 0000000..bdedba6
--- /dev/null
+++ b/libs/gui/tests/FrameWaiter.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_FRAME_WAITER_H
+#define ANDROID_FRAME_WAITER_H
+
+#include <gui/GLConsumer.h>
+
+namespace android {
+
+class FrameWaiter : public GLConsumer::FrameAvailableListener {
+public:
+ FrameWaiter():
+ mPendingFrames(0) {
+ }
+
+ void waitForFrame() {
+ Mutex::Autolock lock(mMutex);
+ while (mPendingFrames == 0) {
+ mCondition.wait(mMutex);
+ }
+ mPendingFrames--;
+ }
+
+ virtual void onFrameAvailable() {
+ Mutex::Autolock lock(mMutex);
+ mPendingFrames++;
+ mCondition.signal();
+ }
+
+private:
+ int mPendingFrames;
+ Mutex mMutex;
+ Condition mCondition;
+};
+
+} // namespace android
+
+#endif
diff --git a/libs/gui/tests/GLTest.cpp b/libs/gui/tests/GLTest.cpp
index d7acb4d..1739d9c 100644
--- a/libs/gui/tests/GLTest.cpp
+++ b/libs/gui/tests/GLTest.cpp
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
#include "GLTest.h"
#include <gui/Surface.h>
@@ -153,7 +169,6 @@
EGLSurface GLTest::createWindowSurface(EGLDisplay display, EGLConfig config,
sp<ANativeWindow>& window) const {
- ALOGI("Creating window surface (non-SRGB)");
return eglCreateWindowSurface(display, config, window.get(), NULL);
}
diff --git a/libs/gui/tests/GLTest.h b/libs/gui/tests/GLTest.h
index 5ba1128..d3c4a95 100644
--- a/libs/gui/tests/GLTest.h
+++ b/libs/gui/tests/GLTest.h
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
#ifndef ANDROID_GL_TEST_H
#define ANDROID_GL_TEST_H
@@ -11,6 +27,12 @@
namespace android {
class GLTest : public ::testing::Test {
+public:
+ static void loadShader(GLenum shaderType, const char* pSource,
+ GLuint* outShader);
+ static void createProgram(const char* pVertexSource,
+ const char* pFragmentSource, GLuint* outPgm);
+
protected:
GLTest() :
mEglDisplay(EGL_NO_DISPLAY),
@@ -33,11 +55,6 @@
::testing::AssertionResult assertRectEq(const Rect &r1, const Rect &r2,
int tolerance = 1);
- static void loadShader(GLenum shaderType, const char* pSource,
- GLuint* outShader);
- static void createProgram(const char* pVertexSource,
- const char* pFragmentSource, GLuint* outPgm);
-
int mDisplaySecs;
sp<SurfaceComposerClient> mComposerClient;
sp<SurfaceControl> mSurfaceControl;
diff --git a/libs/gui/tests/MultiTextureConsumer_test.cpp b/libs/gui/tests/MultiTextureConsumer_test.cpp
new file mode 100644
index 0000000..853c25c
--- /dev/null
+++ b/libs/gui/tests/MultiTextureConsumer_test.cpp
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "MultiTextureConsumer_test"
+//#define LOG_NDEBUG 0
+
+#include "GLTest.h"
+
+#include <gui/GLConsumer.h>
+#include <gui/Surface.h>
+
+#include <android/native_window.h>
+
+#include <GLES/glext.h>
+
+namespace android {
+
+class MultiTextureConsumerTest : public GLTest {
+protected:
+ enum { TEX_ID = 123 };
+
+ virtual void SetUp() {
+ GLTest::SetUp();
+ sp<BufferQueue> bq = new BufferQueue();
+ mGlConsumer = new GLConsumer(bq, TEX_ID);
+ mSurface = new Surface(bq);
+ mANW = mSurface.get();
+
+ }
+ virtual void TearDown() {
+ GLTest::TearDown();
+ }
+ virtual EGLint const* getContextAttribs() {
+ return NULL;
+ }
+ virtual EGLint const* getConfigAttribs() {
+ static EGLint sDefaultConfigAttribs[] = {
+ EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
+ EGL_RED_SIZE, 8,
+ EGL_GREEN_SIZE, 8,
+ EGL_BLUE_SIZE, 8,
+ EGL_ALPHA_SIZE, 8,
+ EGL_NONE };
+
+ return sDefaultConfigAttribs;
+ }
+ sp<GLConsumer> mGlConsumer;
+ sp<Surface> mSurface;
+ ANativeWindow* mANW;
+};
+
+TEST_F(MultiTextureConsumerTest, EGLImageTargetWorks) {
+ ANativeWindow_Buffer buffer;
+
+ ASSERT_EQ(native_window_set_usage(mANW, GRALLOC_USAGE_SW_WRITE_OFTEN), NO_ERROR);
+ ASSERT_EQ(native_window_set_buffers_format(mANW, HAL_PIXEL_FORMAT_RGBA_8888), NO_ERROR);
+
+ glShadeModel(GL_FLAT);
+ glDisable(GL_DITHER);
+ glDisable(GL_CULL_FACE);
+ glViewport(0, 0, getSurfaceWidth(), getSurfaceHeight());
+ glOrthof(0, getSurfaceWidth(), 0, getSurfaceHeight(), 0, 1);
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glColor4f(1, 1, 1, 1);
+
+ glBindTexture(GL_TEXTURE_EXTERNAL_OES, TEX_ID);
+ glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+ glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+ glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+
+ uint32_t texel = 0x80808080;
+ glBindTexture(GL_TEXTURE_2D, TEX_ID+1);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, &texel);
+ glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+ glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+
+ glActiveTexture(GL_TEXTURE1);
+ glBindTexture(GL_TEXTURE_2D, TEX_ID+1);
+ glEnable(GL_TEXTURE_2D);
+ glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+
+ glActiveTexture(GL_TEXTURE0);
+ glBindTexture(GL_TEXTURE_EXTERNAL_OES, TEX_ID);
+ glEnable(GL_TEXTURE_EXTERNAL_OES);
+ glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+
+ glClear(GL_COLOR_BUFFER_BIT);
+ for (int i=0 ; i<8 ; i++) {
+ mSurface->lock(&buffer, NULL);
+ memset(buffer.bits, (i&7) * 0x20, buffer.stride * buffer.height * 4);
+ mSurface->unlockAndPost();
+
+ mGlConsumer->updateTexImage();
+
+ GLfloat vertices[][2] = { {i*16.0f, 0}, {(i+1)*16.0f, 0}, {(i+1)*16.0f, 16.0f}, {i*16.0f, 16.0f} };
+ glVertexPointer(2, GL_FLOAT, 0, vertices);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+ }
+
+ for (int i=0 ; i<8 ; i++) {
+ EXPECT_TRUE(checkPixel(i*16 + 8, 8, i*16, i*16, i*16, i*16, 0));
+ }
+}
+
+} // namespace android
diff --git a/libs/gui/tests/SurfaceTextureFBO.h b/libs/gui/tests/SurfaceTextureFBO.h
new file mode 100644
index 0000000..7f1ae84
--- /dev/null
+++ b/libs/gui/tests/SurfaceTextureFBO.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_SURFACE_TEXTURE_FBO_H
+#define ANDROID_SURFACE_TEXTURE_FBO_H
+
+#include "SurfaceTextureGL.h"
+
+#include <GLES2/gl2.h>
+
+namespace android {
+
+class SurfaceTextureFBOTest : public SurfaceTextureGLTest {
+protected:
+ virtual void SetUp() {
+ SurfaceTextureGLTest::SetUp();
+
+ glGenFramebuffers(1, &mFbo);
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+
+ glGenTextures(1, &mFboTex);
+ glBindTexture(GL_TEXTURE_2D, mFboTex);
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, getSurfaceWidth(),
+ getSurfaceHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+ glBindTexture(GL_TEXTURE_2D, 0);
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+
+ glBindFramebuffer(GL_FRAMEBUFFER, mFbo);
+ glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+ GL_TEXTURE_2D, mFboTex, 0);
+ glBindFramebuffer(GL_FRAMEBUFFER, 0);
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+ }
+
+ virtual void TearDown() {
+ SurfaceTextureGLTest::TearDown();
+
+ glDeleteTextures(1, &mFboTex);
+ glDeleteFramebuffers(1, &mFbo);
+ }
+
+ GLuint mFbo;
+ GLuint mFboTex;
+};
+
+void fillRGBA8BufferSolid(uint8_t* buf, int w, int h, int stride,
+ uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
+ const size_t PIXEL_SIZE = 4;
+ for (int y = 0; y < h; y++) {
+ for (int x = 0; x < w; x++) {
+ off_t offset = (y * stride + x) * PIXEL_SIZE;
+ buf[offset + 0] = r;
+ buf[offset + 1] = g;
+ buf[offset + 2] = b;
+ buf[offset + 3] = a;
+ }
+ }
+}
+
+} // namespace android
+
+#endif
diff --git a/libs/gui/tests/SurfaceTextureFBO_test.cpp b/libs/gui/tests/SurfaceTextureFBO_test.cpp
new file mode 100644
index 0000000..b165ae6
--- /dev/null
+++ b/libs/gui/tests/SurfaceTextureFBO_test.cpp
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "SurfaceTextureFBO_test"
+//#define LOG_NDEBUG 0
+
+#include "SurfaceTextureFBO.h"
+
+namespace android {
+
+// This test is intended to verify that proper synchronization is done when
+// rendering into an FBO.
+TEST_F(SurfaceTextureFBOTest, BlitFromCpuFilledBufferToFbo) {
+ const int texWidth = 64;
+ const int texHeight = 64;
+
+ ASSERT_EQ(NO_ERROR, native_window_set_buffers_geometry(mANW.get(),
+ texWidth, texHeight, HAL_PIXEL_FORMAT_RGBA_8888));
+ ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(),
+ GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN));
+
+ android_native_buffer_t* anb;
+ ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(),
+ &anb));
+ ASSERT_TRUE(anb != NULL);
+
+ sp<GraphicBuffer> buf(new GraphicBuffer(anb, false));
+
+ // Fill the buffer with green
+ uint8_t* img = NULL;
+ buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img));
+ fillRGBA8BufferSolid(img, texWidth, texHeight, buf->getStride(), 0, 255,
+ 0, 255);
+ buf->unlock();
+ ASSERT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), buf->getNativeBuffer(),
+ -1));
+
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+
+ glBindFramebuffer(GL_FRAMEBUFFER, mFbo);
+ drawTexture();
+ glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+ for (int i = 0; i < 4; i++) {
+ SCOPED_TRACE(String8::format("frame %d", i).string());
+
+ ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(),
+ &anb));
+ ASSERT_TRUE(anb != NULL);
+
+ buf = new GraphicBuffer(anb, false);
+
+ // Fill the buffer with red
+ ASSERT_EQ(NO_ERROR, buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN,
+ (void**)(&img)));
+ fillRGBA8BufferSolid(img, texWidth, texHeight, buf->getStride(), 255, 0,
+ 0, 255);
+ ASSERT_EQ(NO_ERROR, buf->unlock());
+ ASSERT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(),
+ buf->getNativeBuffer(), -1));
+
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+
+ drawTexture();
+
+ EXPECT_TRUE(checkPixel( 24, 39, 255, 0, 0, 255));
+ }
+
+ glBindFramebuffer(GL_FRAMEBUFFER, mFbo);
+
+ EXPECT_TRUE(checkPixel( 24, 39, 0, 255, 0, 255));
+}
+
+} // namespace android
diff --git a/libs/gui/tests/SurfaceTextureGL.h b/libs/gui/tests/SurfaceTextureGL.h
new file mode 100644
index 0000000..ac112c4
--- /dev/null
+++ b/libs/gui/tests/SurfaceTextureGL.h
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_SURFACE_TEXTURE_GL_H
+#define ANDROID_SURFACE_TEXTURE_GL_H
+
+#include "GLTest.h"
+
+#include "FrameWaiter.h"
+#include "TextureRenderer.h"
+
+#include <gui/GLConsumer.h>
+#include <gui/Surface.h>
+
+namespace android {
+
+class FrameWaiter;
+class GLConsumer;
+class TextureRenderer;
+
+class SurfaceTextureGLTest : public GLTest {
+protected:
+ enum { TEX_ID = 123 };
+
+ void SetUp() {
+ GLTest::SetUp();
+ sp<BufferQueue> bq = new BufferQueue();
+ mBQ = bq;
+ mST = new GLConsumer(bq, TEX_ID);
+ mSTC = new Surface(bq);
+ mANW = mSTC;
+ mTextureRenderer = new TextureRenderer(TEX_ID, mST);
+ ASSERT_NO_FATAL_FAILURE(mTextureRenderer->SetUp());
+ mFW = new FrameWaiter;
+ mST->setFrameAvailableListener(mFW);
+ }
+
+ void TearDown() {
+ mTextureRenderer.clear();
+ mANW.clear();
+ mSTC.clear();
+ mST.clear();
+ GLTest::TearDown();
+ }
+
+ void drawTexture() {
+ mTextureRenderer->drawTexture();
+ }
+
+ sp<BufferQueue> mBQ;
+ sp<GLConsumer> mST;
+ sp<Surface> mSTC;
+ sp<ANativeWindow> mANW;
+ sp<TextureRenderer> mTextureRenderer;
+ sp<FrameWaiter> mFW;
+};
+
+} // namespace android
+
+#endif
diff --git a/libs/gui/tests/SurfaceTextureGLThreadToGL.h b/libs/gui/tests/SurfaceTextureGLThreadToGL.h
new file mode 100644
index 0000000..6410516
--- /dev/null
+++ b/libs/gui/tests/SurfaceTextureGLThreadToGL.h
@@ -0,0 +1,183 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_SURFACE_TEXTURE_GL_THREAD_TO_GL_H
+#define ANDROID_SURFACE_TEXTURE_GL_THREAD_TO_GL_H
+
+#include "SurfaceTextureGLToGL.h"
+
+namespace android {
+
+/*
+ * This test fixture is for testing GL -> GL texture streaming from one thread
+ * to another. It contains functionality to create a producer thread that will
+ * perform GL rendering to an ANativeWindow that feeds frames to a
+ * GLConsumer. Additionally it supports interlocking the producer and
+ * consumer threads so that a specific sequence of calls can be
+ * deterministically created by the test.
+ *
+ * The intended usage is as follows:
+ *
+ * TEST_F(...) {
+ * class PT : public ProducerThread {
+ * virtual void render() {
+ * ...
+ * swapBuffers();
+ * }
+ * };
+ *
+ * runProducerThread(new PT());
+ *
+ * // The order of these calls will vary from test to test and may include
+ * // multiple frames and additional operations (e.g. GL rendering from the
+ * // texture).
+ * fc->waitForFrame();
+ * mST->updateTexImage();
+ * fc->finishFrame();
+ * }
+ *
+ */
+class SurfaceTextureGLThreadToGLTest : public SurfaceTextureGLToGLTest {
+protected:
+
+ // ProducerThread is an abstract base class to simplify the creation of
+ // OpenGL ES frame producer threads.
+ class ProducerThread : public Thread {
+ public:
+ virtual ~ProducerThread() {
+ }
+
+ void setEglObjects(EGLDisplay producerEglDisplay,
+ EGLSurface producerEglSurface,
+ EGLContext producerEglContext) {
+ mProducerEglDisplay = producerEglDisplay;
+ mProducerEglSurface = producerEglSurface;
+ mProducerEglContext = producerEglContext;
+ }
+
+ virtual bool threadLoop() {
+ eglMakeCurrent(mProducerEglDisplay, mProducerEglSurface,
+ mProducerEglSurface, mProducerEglContext);
+ render();
+ eglMakeCurrent(mProducerEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
+ EGL_NO_CONTEXT);
+ return false;
+ }
+
+ protected:
+ virtual void render() = 0;
+
+ void swapBuffers() {
+ eglSwapBuffers(mProducerEglDisplay, mProducerEglSurface);
+ }
+
+ EGLDisplay mProducerEglDisplay;
+ EGLSurface mProducerEglSurface;
+ EGLContext mProducerEglContext;
+ };
+
+ // FrameCondition is a utility class for interlocking between the producer
+ // and consumer threads. The FrameCondition object should be created and
+ // destroyed in the consumer thread only. The consumer thread should set
+ // the FrameCondition as the FrameAvailableListener of the GLConsumer,
+ // and should call both waitForFrame and finishFrame once for each expected
+ // frame.
+ //
+ // This interlocking relies on the fact that onFrameAvailable gets called
+ // synchronously from GLConsumer::queueBuffer.
+ class FrameCondition : public GLConsumer::FrameAvailableListener {
+ public:
+ FrameCondition():
+ mFrameAvailable(false),
+ mFrameFinished(false) {
+ }
+
+ // waitForFrame waits for the next frame to arrive. This should be
+ // called from the consumer thread once for every frame expected by the
+ // test.
+ void waitForFrame() {
+ Mutex::Autolock lock(mMutex);
+ ALOGV("+waitForFrame");
+ while (!mFrameAvailable) {
+ mFrameAvailableCondition.wait(mMutex);
+ }
+ mFrameAvailable = false;
+ ALOGV("-waitForFrame");
+ }
+
+ // Allow the producer to return from its swapBuffers call and continue
+ // on to produce the next frame. This should be called by the consumer
+ // thread once for every frame expected by the test.
+ void finishFrame() {
+ Mutex::Autolock lock(mMutex);
+ ALOGV("+finishFrame");
+ mFrameFinished = true;
+ mFrameFinishCondition.signal();
+ ALOGV("-finishFrame");
+ }
+
+ // This should be called by GLConsumer on the producer thread.
+ virtual void onFrameAvailable() {
+ Mutex::Autolock lock(mMutex);
+ ALOGV("+onFrameAvailable");
+ mFrameAvailable = true;
+ mFrameAvailableCondition.signal();
+ while (!mFrameFinished) {
+ mFrameFinishCondition.wait(mMutex);
+ }
+ mFrameFinished = false;
+ ALOGV("-onFrameAvailable");
+ }
+
+ protected:
+ bool mFrameAvailable;
+ bool mFrameFinished;
+
+ Mutex mMutex;
+ Condition mFrameAvailableCondition;
+ Condition mFrameFinishCondition;
+ };
+
+ virtual void SetUp() {
+ SurfaceTextureGLToGLTest::SetUp();
+ mFC = new FrameCondition();
+ mST->setFrameAvailableListener(mFC);
+ }
+
+ virtual void TearDown() {
+ if (mProducerThread != NULL) {
+ mProducerThread->requestExitAndWait();
+ }
+ mProducerThread.clear();
+ mFC.clear();
+ SurfaceTextureGLToGLTest::TearDown();
+ }
+
+ void runProducerThread(const sp<ProducerThread> producerThread) {
+ ASSERT_TRUE(mProducerThread == NULL);
+ mProducerThread = producerThread;
+ producerThread->setEglObjects(mEglDisplay, mProducerEglSurface,
+ mProducerEglContext);
+ producerThread->run();
+ }
+
+ sp<ProducerThread> mProducerThread;
+ sp<FrameCondition> mFC;
+};
+
+} // namespace android
+
+#endif
diff --git a/libs/gui/tests/SurfaceTextureGLThreadToGL_test.cpp b/libs/gui/tests/SurfaceTextureGLThreadToGL_test.cpp
new file mode 100644
index 0000000..9776733
--- /dev/null
+++ b/libs/gui/tests/SurfaceTextureGLThreadToGL_test.cpp
@@ -0,0 +1,186 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "SurfaceTextureGLThreadToGL_test"
+//#define LOG_NDEBUG 0
+
+#include "SurfaceTextureGLThreadToGL.h"
+
+namespace android {
+
+TEST_F(SurfaceTextureGLThreadToGLTest,
+ UpdateTexImageBeforeFrameFinishedCompletes) {
+ class PT : public ProducerThread {
+ virtual void render() {
+ glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
+ glClear(GL_COLOR_BUFFER_BIT);
+ swapBuffers();
+ }
+ };
+
+ runProducerThread(new PT());
+
+ mFC->waitForFrame();
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+ mFC->finishFrame();
+
+ // TODO: Add frame verification once RGB TEX_EXTERNAL_OES is supported!
+}
+
+TEST_F(SurfaceTextureGLThreadToGLTest,
+ UpdateTexImageAfterFrameFinishedCompletes) {
+ class PT : public ProducerThread {
+ virtual void render() {
+ glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
+ glClear(GL_COLOR_BUFFER_BIT);
+ swapBuffers();
+ }
+ };
+
+ runProducerThread(new PT());
+
+ mFC->waitForFrame();
+ mFC->finishFrame();
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+
+ // TODO: Add frame verification once RGB TEX_EXTERNAL_OES is supported!
+}
+
+TEST_F(SurfaceTextureGLThreadToGLTest,
+ RepeatedUpdateTexImageBeforeFrameFinishedCompletes) {
+ enum { NUM_ITERATIONS = 1024 };
+
+ class PT : public ProducerThread {
+ virtual void render() {
+ for (int i = 0; i < NUM_ITERATIONS; i++) {
+ glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
+ glClear(GL_COLOR_BUFFER_BIT);
+ ALOGV("+swapBuffers");
+ swapBuffers();
+ ALOGV("-swapBuffers");
+ }
+ }
+ };
+
+ runProducerThread(new PT());
+
+ for (int i = 0; i < NUM_ITERATIONS; i++) {
+ mFC->waitForFrame();
+ ALOGV("+updateTexImage");
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+ ALOGV("-updateTexImage");
+ mFC->finishFrame();
+
+ // TODO: Add frame verification once RGB TEX_EXTERNAL_OES is supported!
+ }
+}
+
+TEST_F(SurfaceTextureGLThreadToGLTest,
+ RepeatedUpdateTexImageAfterFrameFinishedCompletes) {
+ enum { NUM_ITERATIONS = 1024 };
+
+ class PT : public ProducerThread {
+ virtual void render() {
+ for (int i = 0; i < NUM_ITERATIONS; i++) {
+ glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
+ glClear(GL_COLOR_BUFFER_BIT);
+ ALOGV("+swapBuffers");
+ swapBuffers();
+ ALOGV("-swapBuffers");
+ }
+ }
+ };
+
+ runProducerThread(new PT());
+
+ for (int i = 0; i < NUM_ITERATIONS; i++) {
+ mFC->waitForFrame();
+ mFC->finishFrame();
+ ALOGV("+updateTexImage");
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+ ALOGV("-updateTexImage");
+
+ // TODO: Add frame verification once RGB TEX_EXTERNAL_OES is supported!
+ }
+}
+
+// XXX: This test is disabled because it is currently hanging on some devices.
+TEST_F(SurfaceTextureGLThreadToGLTest,
+ DISABLED_RepeatedSwapBuffersWhileDequeueStalledCompletes) {
+ enum { NUM_ITERATIONS = 64 };
+
+ class PT : public ProducerThread {
+ virtual void render() {
+ for (int i = 0; i < NUM_ITERATIONS; i++) {
+ glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
+ glClear(GL_COLOR_BUFFER_BIT);
+ ALOGV("+swapBuffers");
+ swapBuffers();
+ ALOGV("-swapBuffers");
+ }
+ }
+ };
+
+ ASSERT_EQ(OK, mST->setDefaultMaxBufferCount(2));
+
+ runProducerThread(new PT());
+
+ // Allow three frames to be rendered and queued before starting the
+ // rendering in this thread. For the latter two frames we don't call
+ // updateTexImage so the next dequeue from the producer thread will block
+ // waiting for a frame to become available.
+ mFC->waitForFrame();
+ mFC->finishFrame();
+
+ // We must call updateTexImage to consume the first frame so that the
+ // SurfaceTexture is able to reduce the buffer count to 2. This is because
+ // the GL driver may dequeue a buffer when the EGLSurface is created, and
+ // that happens before we call setDefaultMaxBufferCount. It's possible that the
+ // driver does not dequeue a buffer at EGLSurface creation time, so we
+ // cannot rely on this to cause the second dequeueBuffer call to block.
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+
+ mFC->waitForFrame();
+ mFC->finishFrame();
+ mFC->waitForFrame();
+ mFC->finishFrame();
+
+ // Sleep for 100ms to allow the producer thread's dequeueBuffer call to
+ // block waiting for a buffer to become available.
+ usleep(100000);
+
+ // Render and present a number of images. This thread should not be blocked
+ // by the fact that the producer thread is blocking in dequeue.
+ for (int i = 0; i < NUM_ITERATIONS; i++) {
+ glClear(GL_COLOR_BUFFER_BIT);
+ eglSwapBuffers(mEglDisplay, mEglSurface);
+ }
+
+ // Consume the two pending buffers to unblock the producer thread.
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+
+ // Consume the remaining buffers from the producer thread.
+ for (int i = 0; i < NUM_ITERATIONS-3; i++) {
+ mFC->waitForFrame();
+ mFC->finishFrame();
+ ALOGV("+updateTexImage");
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+ ALOGV("-updateTexImage");
+ }
+}
+
+} // namespace android
diff --git a/libs/gui/tests/SurfaceTextureGLToGL.h b/libs/gui/tests/SurfaceTextureGLToGL.h
new file mode 100644
index 0000000..5a2eff3
--- /dev/null
+++ b/libs/gui/tests/SurfaceTextureGLToGL.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_SURFACE_TEXTURE_GL_TO_GL_H
+#define ANDROID_SURFACE_TEXTURE_GL_TO_GL_H
+
+#include "SurfaceTextureGL.h"
+
+namespace android {
+
+/*
+ * This test fixture is for testing GL -> GL texture streaming. It creates an
+ * EGLSurface and an EGLContext for the image producer to use.
+ */
+class SurfaceTextureGLToGLTest : public SurfaceTextureGLTest {
+protected:
+ SurfaceTextureGLToGLTest():
+ mProducerEglSurface(EGL_NO_SURFACE),
+ mProducerEglContext(EGL_NO_CONTEXT) {
+ }
+
+ virtual void SetUp() {
+ SurfaceTextureGLTest::SetUp();
+
+ mProducerEglSurface = eglCreateWindowSurface(mEglDisplay, mGlConfig,
+ mANW.get(), NULL);
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ ASSERT_NE(EGL_NO_SURFACE, mProducerEglSurface);
+
+ mProducerEglContext = eglCreateContext(mEglDisplay, mGlConfig,
+ EGL_NO_CONTEXT, getContextAttribs());
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ ASSERT_NE(EGL_NO_CONTEXT, mProducerEglContext);
+ }
+
+ virtual void TearDown() {
+ if (mProducerEglContext != EGL_NO_CONTEXT) {
+ eglDestroyContext(mEglDisplay, mProducerEglContext);
+ }
+ if (mProducerEglSurface != EGL_NO_SURFACE) {
+ eglDestroySurface(mEglDisplay, mProducerEglSurface);
+ }
+ SurfaceTextureGLTest::TearDown();
+ }
+
+ EGLSurface mProducerEglSurface;
+ EGLContext mProducerEglContext;
+};
+
+} // namespace android
+
+#endif
diff --git a/libs/gui/tests/SurfaceTextureGLToGL_test.cpp b/libs/gui/tests/SurfaceTextureGLToGL_test.cpp
new file mode 100644
index 0000000..f4c7961
--- /dev/null
+++ b/libs/gui/tests/SurfaceTextureGLToGL_test.cpp
@@ -0,0 +1,502 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "SurfaceTextureGLToGL_test"
+//#define LOG_NDEBUG 0
+
+#include "SurfaceTextureGLToGL.h"
+
+namespace android {
+
+TEST_F(SurfaceTextureGLToGLTest, TransformHintGetsRespected) {
+ const uint32_t texWidth = 32;
+ const uint32_t texHeight = 64;
+
+ mST->setDefaultBufferSize(texWidth, texHeight);
+ mST->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_90);
+
+ // This test requires 3 buffers to avoid deadlock because we're
+ // both producer and consumer, and only using one thread.
+ mST->setDefaultMaxBufferCount(3);
+
+ // Do the producer side of things
+ EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
+ mProducerEglSurface, mProducerEglContext));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+
+ // Start a buffer with our chosen size and transform hint moving
+ // through the system.
+ glClear(GL_COLOR_BUFFER_BIT); // give the driver something to do
+ eglSwapBuffers(mEglDisplay, mProducerEglSurface);
+ mST->updateTexImage(); // consume it
+ // Swap again.
+ glClear(GL_COLOR_BUFFER_BIT);
+ eglSwapBuffers(mEglDisplay, mProducerEglSurface);
+ mST->updateTexImage();
+
+ // The current buffer should either show the effects of the transform
+ // hint (in the form of an inverse transform), or show that the
+ // transform hint has been ignored.
+ sp<GraphicBuffer> buf = mST->getCurrentBuffer();
+ if (mST->getCurrentTransform() == NATIVE_WINDOW_TRANSFORM_ROT_270) {
+ ASSERT_EQ(texWidth, buf->getHeight());
+ ASSERT_EQ(texHeight, buf->getWidth());
+ } else {
+ ASSERT_EQ(texWidth, buf->getWidth());
+ ASSERT_EQ(texHeight, buf->getHeight());
+ }
+
+ // Reset the transform hint and confirm that it takes.
+ mST->setTransformHint(0);
+ glClear(GL_COLOR_BUFFER_BIT);
+ eglSwapBuffers(mEglDisplay, mProducerEglSurface);
+ mST->updateTexImage();
+ glClear(GL_COLOR_BUFFER_BIT);
+ eglSwapBuffers(mEglDisplay, mProducerEglSurface);
+ mST->updateTexImage();
+
+ buf = mST->getCurrentBuffer();
+ ASSERT_EQ((uint32_t) 0, mST->getCurrentTransform());
+ ASSERT_EQ(texWidth, buf->getWidth());
+ ASSERT_EQ(texHeight, buf->getHeight());
+}
+
+TEST_F(SurfaceTextureGLToGLTest, TexturingFromGLFilledRGBABufferPow2) {
+ const int texWidth = 64;
+ const int texHeight = 64;
+
+ mST->setDefaultBufferSize(texWidth, texHeight);
+
+ // This test requires 3 buffers to complete run on a single thread.
+ mST->setDefaultMaxBufferCount(3);
+
+ // Do the producer side of things
+ EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
+ mProducerEglSurface, mProducerEglContext));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+
+ // This is needed to ensure we pick up a buffer of the correct size.
+ eglSwapBuffers(mEglDisplay, mProducerEglSurface);
+
+ glClearColor(0.6, 0.6, 0.6, 0.6);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glEnable(GL_SCISSOR_TEST);
+ glScissor(4, 4, 4, 4);
+ glClearColor(1.0, 0.0, 0.0, 1.0);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glScissor(24, 48, 4, 4);
+ glClearColor(0.0, 1.0, 0.0, 1.0);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glScissor(37, 17, 4, 4);
+ glClearColor(0.0, 0.0, 1.0, 1.0);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ eglSwapBuffers(mEglDisplay, mProducerEglSurface);
+
+ // Do the consumer side of things
+ EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
+ mEglContext));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+
+ glDisable(GL_SCISSOR_TEST);
+
+ // Skip the first frame, which was empty
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+
+ glClearColor(0.2, 0.2, 0.2, 0.2);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glViewport(0, 0, texWidth, texHeight);
+ drawTexture();
+
+ EXPECT_TRUE(checkPixel( 0, 0, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(63, 0, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(63, 63, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel( 0, 63, 153, 153, 153, 153));
+
+ EXPECT_TRUE(checkPixel( 4, 7, 255, 0, 0, 255));
+ EXPECT_TRUE(checkPixel(25, 51, 0, 255, 0, 255));
+ EXPECT_TRUE(checkPixel(40, 19, 0, 0, 255, 255));
+ EXPECT_TRUE(checkPixel(29, 51, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel( 5, 32, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(13, 8, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(46, 3, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(30, 33, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel( 6, 52, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(55, 33, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(16, 29, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel( 1, 30, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(41, 37, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(46, 29, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(15, 25, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel( 3, 52, 153, 153, 153, 153));
+}
+
+TEST_F(SurfaceTextureGLToGLTest, EglDestroySurfaceUnrefsBuffers) {
+ sp<GraphicBuffer> buffers[2];
+
+ // This test requires async mode to run on a single thread.
+ EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
+ mProducerEglSurface, mProducerEglContext));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ EXPECT_TRUE(eglSwapInterval(mEglDisplay, 0));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+
+ for (int i = 0; i < 2; i++) {
+ // Produce a frame
+ EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
+ mProducerEglSurface, mProducerEglContext));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ glClear(GL_COLOR_BUFFER_BIT);
+ eglSwapBuffers(mEglDisplay, mProducerEglSurface);
+
+ // Consume a frame
+ EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
+ mEglContext));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ mFW->waitForFrame();
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+ buffers[i] = mST->getCurrentBuffer();
+ }
+
+ // Destroy the GL texture object to release its ref on buffers[2].
+ GLuint texID = TEX_ID;
+ glDeleteTextures(1, &texID);
+
+ // Destroy the EGLSurface
+ EXPECT_TRUE(eglDestroySurface(mEglDisplay, mProducerEglSurface));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ mProducerEglSurface = EGL_NO_SURFACE;
+
+ // This test should have the only reference to buffer 0.
+ EXPECT_EQ(1, buffers[0]->getStrongCount());
+
+ // The GLConsumer should hold a single reference to buffer 1 in its
+ // mCurrentBuffer member. All of the references in the slots should have
+ // been released.
+ EXPECT_EQ(2, buffers[1]->getStrongCount());
+}
+
+TEST_F(SurfaceTextureGLToGLTest, EglDestroySurfaceAfterAbandonUnrefsBuffers) {
+ sp<GraphicBuffer> buffers[3];
+
+ // This test requires async mode to run on a single thread.
+ EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
+ mProducerEglSurface, mProducerEglContext));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ EXPECT_TRUE(eglSwapInterval(mEglDisplay, 0));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+
+ for (int i = 0; i < 3; i++) {
+ // Produce a frame
+ EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
+ mProducerEglSurface, mProducerEglContext));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ glClear(GL_COLOR_BUFFER_BIT);
+ EXPECT_TRUE(eglSwapBuffers(mEglDisplay, mProducerEglSurface));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+
+ // Consume a frame
+ EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
+ mEglContext));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ mFW->waitForFrame();
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+ buffers[i] = mST->getCurrentBuffer();
+ }
+
+ // Abandon the GLConsumer, releasing the ref that the GLConsumer has
+ // on buffers[2].
+ mST->abandon();
+
+ // Destroy the GL texture object to release its ref on buffers[2].
+ GLuint texID = TEX_ID;
+ glDeleteTextures(1, &texID);
+
+ // Destroy the EGLSurface.
+ EXPECT_TRUE(eglDestroySurface(mEglDisplay, mProducerEglSurface));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ mProducerEglSurface = EGL_NO_SURFACE;
+
+ EXPECT_EQ(1, buffers[0]->getStrongCount());
+ EXPECT_EQ(1, buffers[1]->getStrongCount());
+
+ // Depending on how lazily the GL driver dequeues buffers, we may end up
+ // with either two or three total buffers. If there are three, make sure
+ // the last one was properly down-ref'd.
+ if (buffers[2] != buffers[0]) {
+ EXPECT_EQ(1, buffers[2]->getStrongCount());
+ }
+}
+
+TEST_F(SurfaceTextureGLToGLTest, EglMakeCurrentBeforeConsumerDeathUnrefsBuffers) {
+ sp<GraphicBuffer> buffer;
+
+ EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
+ mProducerEglSurface, mProducerEglContext));
+
+ // Produce a frame
+ glClear(GL_COLOR_BUFFER_BIT);
+ EXPECT_TRUE(eglSwapBuffers(mEglDisplay, mProducerEglSurface));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+
+ // Destroy the EGLSurface.
+ EXPECT_TRUE(eglDestroySurface(mEglDisplay, mProducerEglSurface));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ mProducerEglSurface = EGL_NO_SURFACE;
+ mSTC.clear();
+ mANW.clear();
+ mTextureRenderer.clear();
+
+ // Consume a frame
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+ buffer = mST->getCurrentBuffer();
+
+ // Destroy the GL texture object to release its ref
+ GLuint texID = TEX_ID;
+ glDeleteTextures(1, &texID);
+
+ // make un-current, all references to buffer should be gone
+ EXPECT_TRUE(eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE,
+ EGL_NO_SURFACE, EGL_NO_CONTEXT));
+
+ // Destroy consumer
+ mST.clear();
+
+ EXPECT_EQ(1, buffer->getStrongCount());
+}
+
+TEST_F(SurfaceTextureGLToGLTest, EglMakeCurrentAfterConsumerDeathUnrefsBuffers) {
+ sp<GraphicBuffer> buffer;
+
+ EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
+ mProducerEglSurface, mProducerEglContext));
+
+ // Produce a frame
+ glClear(GL_COLOR_BUFFER_BIT);
+ EXPECT_TRUE(eglSwapBuffers(mEglDisplay, mProducerEglSurface));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+
+ // Destroy the EGLSurface.
+ EXPECT_TRUE(eglDestroySurface(mEglDisplay, mProducerEglSurface));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ mProducerEglSurface = EGL_NO_SURFACE;
+ mSTC.clear();
+ mANW.clear();
+ mTextureRenderer.clear();
+
+ // Consume a frame
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+ buffer = mST->getCurrentBuffer();
+
+ // Destroy the GL texture object to release its ref
+ GLuint texID = TEX_ID;
+ glDeleteTextures(1, &texID);
+
+ // Destroy consumer
+ mST.clear();
+
+ // make un-current, all references to buffer should be gone
+ EXPECT_TRUE(eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE,
+ EGL_NO_SURFACE, EGL_NO_CONTEXT));
+
+ EXPECT_EQ(1, buffer->getStrongCount());
+}
+
+TEST_F(SurfaceTextureGLToGLTest, TexturingFromUserSizedGLFilledBuffer) {
+ enum { texWidth = 64 };
+ enum { texHeight = 64 };
+
+ // This test requires 3 buffers to complete run on a single thread.
+ mST->setDefaultMaxBufferCount(3);
+
+ // Set the user buffer size.
+ native_window_set_buffers_user_dimensions(mANW.get(), texWidth, texHeight);
+
+ // Do the producer side of things
+ EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
+ mProducerEglSurface, mProducerEglContext));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+
+ // This is needed to ensure we pick up a buffer of the correct size.
+ eglSwapBuffers(mEglDisplay, mProducerEglSurface);
+
+ glClearColor(0.6, 0.6, 0.6, 0.6);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glEnable(GL_SCISSOR_TEST);
+ glScissor(4, 4, 1, 1);
+ glClearColor(1.0, 0.0, 0.0, 1.0);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ eglSwapBuffers(mEglDisplay, mProducerEglSurface);
+
+ // Do the consumer side of things
+ EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
+ mEglContext));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+
+ glDisable(GL_SCISSOR_TEST);
+
+ // Skip the first frame, which was empty
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+
+ glClearColor(0.2, 0.2, 0.2, 0.2);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glViewport(0, 0, texWidth, texHeight);
+ drawTexture();
+
+ EXPECT_TRUE(checkPixel( 0, 0, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(63, 0, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(63, 63, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel( 0, 63, 153, 153, 153, 153));
+
+ EXPECT_TRUE(checkPixel( 4, 4, 255, 0, 0, 255));
+ EXPECT_TRUE(checkPixel( 5, 5, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel( 3, 3, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(45, 52, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(12, 36, 153, 153, 153, 153));
+}
+
+TEST_F(SurfaceTextureGLToGLTest, TexturingFromPreRotatedUserSizedGLFilledBuffer) {
+ enum { texWidth = 64 };
+ enum { texHeight = 16 };
+
+ // This test requires 3 buffers to complete run on a single thread.
+ mST->setDefaultMaxBufferCount(3);
+
+ // Set the transform hint.
+ mST->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_90);
+
+ // Set the user buffer size.
+ native_window_set_buffers_user_dimensions(mANW.get(), texWidth, texHeight);
+
+ // Do the producer side of things
+ EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
+ mProducerEglSurface, mProducerEglContext));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+
+ // This is needed to ensure we pick up a buffer of the correct size and the
+ // new rotation hint.
+ eglSwapBuffers(mEglDisplay, mProducerEglSurface);
+
+ glClearColor(0.6, 0.6, 0.6, 0.6);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glEnable(GL_SCISSOR_TEST);
+ glScissor(24, 4, 1, 1);
+ glClearColor(1.0, 0.0, 0.0, 1.0);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ eglSwapBuffers(mEglDisplay, mProducerEglSurface);
+
+ // Do the consumer side of things
+ EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
+ mEglContext));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+
+ glDisable(GL_SCISSOR_TEST);
+
+ // Skip the first frame, which was empty
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+
+ glClearColor(0.2, 0.2, 0.2, 0.2);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glViewport(0, 0, texWidth, texHeight);
+ drawTexture();
+
+ EXPECT_TRUE(checkPixel( 0, 0, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(63, 0, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(63, 15, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel( 0, 15, 153, 153, 153, 153));
+
+ EXPECT_TRUE(checkPixel(24, 4, 255, 0, 0, 255));
+ EXPECT_TRUE(checkPixel(25, 5, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(23, 3, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(45, 13, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(12, 8, 153, 153, 153, 153));
+}
+
+TEST_F(SurfaceTextureGLToGLTest, TexturingFromPreRotatedGLFilledBuffer) {
+ enum { texWidth = 64 };
+ enum { texHeight = 16 };
+
+ // This test requires 3 buffers to complete run on a single thread.
+ mST->setDefaultMaxBufferCount(3);
+
+ // Set the transform hint.
+ mST->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_90);
+
+ // Set the default buffer size.
+ mST->setDefaultBufferSize(texWidth, texHeight);
+
+ // Do the producer side of things
+ EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
+ mProducerEglSurface, mProducerEglContext));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+
+ // This is needed to ensure we pick up a buffer of the correct size and the
+ // new rotation hint.
+ eglSwapBuffers(mEglDisplay, mProducerEglSurface);
+
+ glClearColor(0.6, 0.6, 0.6, 0.6);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glEnable(GL_SCISSOR_TEST);
+ glScissor(24, 4, 1, 1);
+ glClearColor(1.0, 0.0, 0.0, 1.0);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ eglSwapBuffers(mEglDisplay, mProducerEglSurface);
+
+ // Do the consumer side of things
+ EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
+ mEglContext));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+
+ glDisable(GL_SCISSOR_TEST);
+
+ // Skip the first frame, which was empty
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+
+ glClearColor(0.2, 0.2, 0.2, 0.2);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glViewport(0, 0, texWidth, texHeight);
+ drawTexture();
+
+ EXPECT_TRUE(checkPixel( 0, 0, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(63, 0, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(63, 15, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel( 0, 15, 153, 153, 153, 153));
+
+ EXPECT_TRUE(checkPixel(24, 4, 255, 0, 0, 255));
+ EXPECT_TRUE(checkPixel(25, 5, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(23, 3, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(45, 13, 153, 153, 153, 153));
+ EXPECT_TRUE(checkPixel(12, 8, 153, 153, 153, 153));
+}
+
+} // namespace android
diff --git a/libs/gui/tests/SurfaceTextureGL_test.cpp b/libs/gui/tests/SurfaceTextureGL_test.cpp
new file mode 100644
index 0000000..25b2319
--- /dev/null
+++ b/libs/gui/tests/SurfaceTextureGL_test.cpp
@@ -0,0 +1,703 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "SurfaceTextureGL_test"
+//#define LOG_NDEBUG 0
+
+#include "SurfaceTextureGL.h"
+
+#include "DisconnectWaiter.h"
+#include "FillBuffer.h"
+
+namespace android {
+
+TEST_F(SurfaceTextureGLTest, TexturingFromCpuFilledYV12BufferNpot) {
+ const int texWidth = 64;
+ const int texHeight = 66;
+
+ ASSERT_EQ(NO_ERROR, native_window_set_buffers_geometry(mANW.get(),
+ texWidth, texHeight, HAL_PIXEL_FORMAT_YV12));
+ ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(),
+ GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN));
+
+ ANativeWindowBuffer* anb;
+ ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(),
+ &anb));
+ ASSERT_TRUE(anb != NULL);
+
+ sp<GraphicBuffer> buf(new GraphicBuffer(anb, false));
+
+ // Fill the buffer with the a checkerboard pattern
+ uint8_t* img = NULL;
+ buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img));
+ fillYV12Buffer(img, texWidth, texHeight, buf->getStride());
+ buf->unlock();
+ ASSERT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), buf->getNativeBuffer(),
+ -1));
+
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+
+ glClearColor(0.2, 0.2, 0.2, 0.2);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glViewport(0, 0, texWidth, texHeight);
+ drawTexture();
+
+ EXPECT_TRUE(checkPixel( 0, 0, 255, 127, 255, 255, 3));
+ EXPECT_TRUE(checkPixel(63, 0, 0, 133, 0, 255, 3));
+ EXPECT_TRUE(checkPixel(63, 65, 0, 133, 0, 255, 3));
+ EXPECT_TRUE(checkPixel( 0, 65, 255, 127, 255, 255, 3));
+
+ EXPECT_TRUE(checkPixel(22, 44, 255, 127, 255, 255, 3));
+ EXPECT_TRUE(checkPixel(45, 52, 255, 127, 255, 255, 3));
+ EXPECT_TRUE(checkPixel(52, 51, 98, 255, 73, 255, 3));
+ EXPECT_TRUE(checkPixel( 7, 31, 155, 0, 118, 255, 3));
+ EXPECT_TRUE(checkPixel(31, 9, 107, 24, 87, 255, 3));
+ EXPECT_TRUE(checkPixel(29, 35, 255, 127, 255, 255, 3));
+ EXPECT_TRUE(checkPixel(36, 22, 155, 29, 0, 255, 3));
+}
+
+TEST_F(SurfaceTextureGLTest, TexturingFromCpuFilledYV12BufferPow2) {
+ const int texWidth = 64;
+ const int texHeight = 64;
+
+ ASSERT_EQ(NO_ERROR, native_window_set_buffers_geometry(mANW.get(),
+ texWidth, texHeight, HAL_PIXEL_FORMAT_YV12));
+ ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(),
+ GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN));
+
+ ANativeWindowBuffer* anb;
+ ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(),
+ &anb));
+ ASSERT_TRUE(anb != NULL);
+
+ sp<GraphicBuffer> buf(new GraphicBuffer(anb, false));
+
+ // Fill the buffer with the a checkerboard pattern
+ uint8_t* img = NULL;
+ buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img));
+ fillYV12Buffer(img, texWidth, texHeight, buf->getStride());
+ buf->unlock();
+ ASSERT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), buf->getNativeBuffer(),
+ -1));
+
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+
+ glClearColor(0.2, 0.2, 0.2, 0.2);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glViewport(0, 0, texWidth, texHeight);
+ drawTexture();
+
+ EXPECT_TRUE(checkPixel( 0, 0, 0, 133, 0, 255));
+ EXPECT_TRUE(checkPixel(63, 0, 255, 127, 255, 255));
+ EXPECT_TRUE(checkPixel(63, 63, 0, 133, 0, 255));
+ EXPECT_TRUE(checkPixel( 0, 63, 255, 127, 255, 255));
+
+ EXPECT_TRUE(checkPixel(22, 19, 100, 255, 74, 255));
+ EXPECT_TRUE(checkPixel(45, 11, 100, 255, 74, 255));
+ EXPECT_TRUE(checkPixel(52, 12, 155, 0, 181, 255));
+ EXPECT_TRUE(checkPixel( 7, 32, 150, 237, 170, 255));
+ EXPECT_TRUE(checkPixel(31, 54, 0, 71, 117, 255));
+ EXPECT_TRUE(checkPixel(29, 28, 0, 133, 0, 255));
+ EXPECT_TRUE(checkPixel(36, 41, 100, 232, 255, 255));
+}
+
+TEST_F(SurfaceTextureGLTest, TexturingFromCpuFilledYV12BufferWithCrop) {
+ const int texWidth = 64;
+ const int texHeight = 66;
+
+ ASSERT_EQ(NO_ERROR, native_window_set_buffers_geometry(mANW.get(),
+ texWidth, texHeight, HAL_PIXEL_FORMAT_YV12));
+ ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(),
+ GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN));
+
+ android_native_rect_t crops[] = {
+ {4, 6, 22, 36},
+ {0, 6, 22, 36},
+ {4, 0, 22, 36},
+ {4, 6, texWidth, 36},
+ {4, 6, 22, texHeight},
+ };
+
+ for (int i = 0; i < 5; i++) {
+ const android_native_rect_t& crop(crops[i]);
+ SCOPED_TRACE(String8::format("rect{ l: %d t: %d r: %d b: %d }",
+ crop.left, crop.top, crop.right, crop.bottom).string());
+
+ ASSERT_EQ(NO_ERROR, native_window_set_crop(mANW.get(), &crop));
+
+ ANativeWindowBuffer* anb;
+ ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(),
+ &anb));
+ ASSERT_TRUE(anb != NULL);
+
+ sp<GraphicBuffer> buf(new GraphicBuffer(anb, false));
+
+ uint8_t* img = NULL;
+ buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img));
+ fillYV12BufferRect(img, texWidth, texHeight, buf->getStride(), crop);
+ buf->unlock();
+ ASSERT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(),
+ buf->getNativeBuffer(), -1));
+
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+
+ glClearColor(0.2, 0.2, 0.2, 0.2);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glViewport(0, 0, 64, 64);
+ drawTexture();
+
+ EXPECT_TRUE(checkPixel( 0, 0, 82, 255, 35, 255));
+ EXPECT_TRUE(checkPixel(63, 0, 82, 255, 35, 255));
+ EXPECT_TRUE(checkPixel(63, 63, 82, 255, 35, 255));
+ EXPECT_TRUE(checkPixel( 0, 63, 82, 255, 35, 255));
+
+ EXPECT_TRUE(checkPixel(25, 14, 82, 255, 35, 255));
+ EXPECT_TRUE(checkPixel(35, 31, 82, 255, 35, 255));
+ EXPECT_TRUE(checkPixel(57, 6, 82, 255, 35, 255));
+ EXPECT_TRUE(checkPixel( 5, 42, 82, 255, 35, 255));
+ EXPECT_TRUE(checkPixel(32, 33, 82, 255, 35, 255));
+ EXPECT_TRUE(checkPixel(16, 26, 82, 255, 35, 255));
+ EXPECT_TRUE(checkPixel(46, 51, 82, 255, 35, 255));
+ }
+}
+
+// This test is intended to catch synchronization bugs between the CPU-written
+// and GPU-read buffers.
+TEST_F(SurfaceTextureGLTest, TexturingFromCpuFilledYV12BuffersRepeatedly) {
+ enum { texWidth = 16 };
+ enum { texHeight = 16 };
+ enum { numFrames = 1024 };
+
+ ASSERT_EQ(NO_ERROR, mST->setDefaultMaxBufferCount(2));
+ ASSERT_EQ(NO_ERROR, native_window_set_buffers_geometry(mANW.get(),
+ texWidth, texHeight, HAL_PIXEL_FORMAT_YV12));
+ ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(),
+ GRALLOC_USAGE_SW_WRITE_OFTEN));
+
+ struct TestPixel {
+ int x;
+ int y;
+ };
+ const TestPixel testPixels[] = {
+ { 4, 11 },
+ { 12, 14 },
+ { 7, 2 },
+ };
+ enum {numTestPixels = sizeof(testPixels) / sizeof(testPixels[0])};
+
+ class ProducerThread : public Thread {
+ public:
+ ProducerThread(const sp<ANativeWindow>& anw,
+ const TestPixel* testPixels):
+ mANW(anw),
+ mTestPixels(testPixels) {
+ }
+
+ virtual ~ProducerThread() {
+ }
+
+ virtual bool threadLoop() {
+ for (int i = 0; i < numFrames; i++) {
+ ANativeWindowBuffer* anb;
+ if (native_window_dequeue_buffer_and_wait(mANW.get(),
+ &anb) != NO_ERROR) {
+ return false;
+ }
+ if (anb == NULL) {
+ return false;
+ }
+
+ sp<GraphicBuffer> buf(new GraphicBuffer(anb, false));
+
+ const int yuvTexOffsetY = 0;
+ int stride = buf->getStride();
+ int yuvTexStrideY = stride;
+ int yuvTexOffsetV = yuvTexStrideY * texHeight;
+ int yuvTexStrideV = (yuvTexStrideY/2 + 0xf) & ~0xf;
+ int yuvTexOffsetU = yuvTexOffsetV + yuvTexStrideV * texHeight/2;
+ int yuvTexStrideU = yuvTexStrideV;
+
+ uint8_t* img = NULL;
+ buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img));
+
+ // Gray out all the test pixels first, so we're more likely to
+ // see a failure if GL is still texturing from the buffer we
+ // just dequeued.
+ for (int j = 0; j < numTestPixels; j++) {
+ int x = mTestPixels[j].x;
+ int y = mTestPixels[j].y;
+ uint8_t value = 128;
+ img[y*stride + x] = value;
+ }
+
+ // Fill the buffer with gray.
+ for (int y = 0; y < texHeight; y++) {
+ for (int x = 0; x < texWidth; x++) {
+ img[yuvTexOffsetY + y*yuvTexStrideY + x] = 128;
+ img[yuvTexOffsetU + (y/2)*yuvTexStrideU + x/2] = 128;
+ img[yuvTexOffsetV + (y/2)*yuvTexStrideV + x/2] = 128;
+ }
+ }
+
+ // Set the test pixels to either white or black.
+ for (int j = 0; j < numTestPixels; j++) {
+ int x = mTestPixels[j].x;
+ int y = mTestPixels[j].y;
+ uint8_t value = 0;
+ if (j == (i % numTestPixels)) {
+ value = 255;
+ }
+ img[y*stride + x] = value;
+ }
+
+ buf->unlock();
+ if (mANW->queueBuffer(mANW.get(), buf->getNativeBuffer(), -1)
+ != NO_ERROR) {
+ return false;
+ }
+ }
+ return false;
+ }
+
+ sp<ANativeWindow> mANW;
+ const TestPixel* mTestPixels;
+ };
+
+ sp<Thread> pt(new ProducerThread(mANW, testPixels));
+ pt->run();
+
+ glViewport(0, 0, texWidth, texHeight);
+
+ glClearColor(0.2, 0.2, 0.2, 0.2);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ // We wait for the first two frames up front so that the producer will be
+ // likely to dequeue the buffer that's currently being textured from.
+ mFW->waitForFrame();
+ mFW->waitForFrame();
+
+ for (int i = 0; i < numFrames; i++) {
+ SCOPED_TRACE(String8::format("frame %d", i).string());
+
+ // We must wait for each frame to come in because if we ever do an
+ // updateTexImage call that doesn't consume a newly available buffer
+ // then the producer and consumer will get out of sync, which will cause
+ // a deadlock.
+ if (i > 1) {
+ mFW->waitForFrame();
+ }
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+ drawTexture();
+
+ for (int j = 0; j < numTestPixels; j++) {
+ int x = testPixels[j].x;
+ int y = testPixels[j].y;
+ uint8_t value = 0;
+ if (j == (i % numTestPixels)) {
+ // We must y-invert the texture coords
+ EXPECT_TRUE(checkPixel(x, texHeight-y-1, 255, 255, 255, 255));
+ } else {
+ // We must y-invert the texture coords
+ EXPECT_TRUE(checkPixel(x, texHeight-y-1, 0, 0, 0, 255));
+ }
+ }
+ }
+
+ pt->requestExitAndWait();
+}
+
+TEST_F(SurfaceTextureGLTest, TexturingFromCpuFilledRGBABufferNpot) {
+ const int texWidth = 64;
+ const int texHeight = 66;
+
+ ASSERT_EQ(NO_ERROR, native_window_set_buffers_geometry(mANW.get(),
+ texWidth, texHeight, HAL_PIXEL_FORMAT_RGBA_8888));
+ ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(),
+ GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN));
+
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+
+ glClearColor(0.2, 0.2, 0.2, 0.2);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glViewport(0, 0, texWidth, texHeight);
+ drawTexture();
+
+ EXPECT_TRUE(checkPixel( 0, 0, 35, 35, 35, 35));
+ EXPECT_TRUE(checkPixel(63, 0, 231, 231, 231, 231));
+ EXPECT_TRUE(checkPixel(63, 65, 231, 231, 231, 231));
+ EXPECT_TRUE(checkPixel( 0, 65, 35, 35, 35, 35));
+
+ EXPECT_TRUE(checkPixel(15, 10, 35, 231, 231, 231));
+ EXPECT_TRUE(checkPixel(23, 65, 231, 35, 231, 35));
+ EXPECT_TRUE(checkPixel(19, 40, 35, 231, 35, 35));
+ EXPECT_TRUE(checkPixel(38, 30, 231, 35, 35, 35));
+ EXPECT_TRUE(checkPixel(42, 54, 35, 35, 35, 231));
+ EXPECT_TRUE(checkPixel(37, 34, 35, 231, 231, 231));
+ EXPECT_TRUE(checkPixel(31, 8, 231, 35, 35, 231));
+ EXPECT_TRUE(checkPixel(37, 47, 231, 35, 231, 231));
+ EXPECT_TRUE(checkPixel(25, 38, 35, 35, 35, 35));
+ EXPECT_TRUE(checkPixel(49, 6, 35, 231, 35, 35));
+ EXPECT_TRUE(checkPixel(54, 50, 35, 231, 231, 231));
+ EXPECT_TRUE(checkPixel(27, 26, 231, 231, 231, 231));
+ EXPECT_TRUE(checkPixel(10, 6, 35, 35, 231, 231));
+ EXPECT_TRUE(checkPixel(29, 4, 35, 35, 35, 231));
+ EXPECT_TRUE(checkPixel(55, 28, 35, 35, 231, 35));
+ EXPECT_TRUE(checkPixel(58, 55, 35, 35, 231, 231));
+}
+
+TEST_F(SurfaceTextureGLTest, TexturingFromCpuFilledRGBABufferPow2) {
+ const int texWidth = 64;
+ const int texHeight = 64;
+
+ ASSERT_EQ(NO_ERROR, native_window_set_buffers_geometry(mANW.get(),
+ texWidth, texHeight, HAL_PIXEL_FORMAT_RGBA_8888));
+ ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(),
+ GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN));
+
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+
+ ASSERT_EQ(NO_ERROR, mST->updateTexImage());
+
+ glClearColor(0.2, 0.2, 0.2, 0.2);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glViewport(0, 0, texWidth, texHeight);
+ drawTexture();
+
+ EXPECT_TRUE(checkPixel( 0, 0, 231, 231, 231, 231));
+ EXPECT_TRUE(checkPixel(63, 0, 35, 35, 35, 35));
+ EXPECT_TRUE(checkPixel(63, 63, 231, 231, 231, 231));
+ EXPECT_TRUE(checkPixel( 0, 63, 35, 35, 35, 35));
+
+ EXPECT_TRUE(checkPixel(12, 46, 231, 231, 231, 35));
+ EXPECT_TRUE(checkPixel(16, 1, 231, 231, 35, 231));
+ EXPECT_TRUE(checkPixel(21, 12, 231, 35, 35, 231));
+ EXPECT_TRUE(checkPixel(26, 51, 231, 35, 231, 35));
+ EXPECT_TRUE(checkPixel( 5, 32, 35, 231, 231, 35));
+ EXPECT_TRUE(checkPixel(13, 8, 35, 231, 231, 231));
+ EXPECT_TRUE(checkPixel(46, 3, 35, 35, 231, 35));
+ EXPECT_TRUE(checkPixel(30, 33, 35, 35, 35, 35));
+ EXPECT_TRUE(checkPixel( 6, 52, 231, 231, 35, 35));
+ EXPECT_TRUE(checkPixel(55, 33, 35, 231, 35, 231));
+ EXPECT_TRUE(checkPixel(16, 29, 35, 35, 231, 231));
+ EXPECT_TRUE(checkPixel( 1, 30, 35, 35, 35, 231));
+ EXPECT_TRUE(checkPixel(41, 37, 35, 35, 231, 231));
+ EXPECT_TRUE(checkPixel(46, 29, 231, 231, 35, 35));
+ EXPECT_TRUE(checkPixel(15, 25, 35, 231, 35, 231));
+ EXPECT_TRUE(checkPixel( 3, 52, 35, 231, 35, 35));
+}
+
+// Tests if GLConsumer and BufferQueue are robust enough
+// to handle a special case where updateTexImage is called
+// in the middle of disconnect. This ordering is enforced
+// by blocking in the disconnect callback.
+TEST_F(SurfaceTextureGLTest, DisconnectStressTest) {
+
+ class ProducerThread : public Thread {
+ public:
+ ProducerThread(const sp<ANativeWindow>& anw):
+ mANW(anw) {
+ }
+
+ virtual ~ProducerThread() {
+ }
+
+ virtual bool threadLoop() {
+ ANativeWindowBuffer* anb;
+
+ native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_EGL);
+
+ for (int numFrames =0 ; numFrames < 2; numFrames ++) {
+
+ if (native_window_dequeue_buffer_and_wait(mANW.get(),
+ &anb) != NO_ERROR) {
+ return false;
+ }
+ if (anb == NULL) {
+ return false;
+ }
+ if (mANW->queueBuffer(mANW.get(), anb, -1)
+ != NO_ERROR) {
+ return false;
+ }
+ }
+
+ native_window_api_disconnect(mANW.get(), NATIVE_WINDOW_API_EGL);
+
+ return false;
+ }
+
+ private:
+ sp<ANativeWindow> mANW;
+ };
+
+ sp<DisconnectWaiter> dw(new DisconnectWaiter());
+ mBQ->consumerConnect(dw, false);
+
+
+ sp<Thread> pt(new ProducerThread(mANW));
+ pt->run();
+
+ // eat a frame so GLConsumer will own an at least one slot
+ dw->waitForFrame();
+ EXPECT_EQ(OK,mST->updateTexImage());
+
+ dw->waitForFrame();
+ // Could fail here as GLConsumer thinks it still owns the slot
+ // but bufferQueue has released all slots
+ EXPECT_EQ(OK,mST->updateTexImage());
+
+ dw->finishDisconnect();
+}
+
+
+// This test ensures that the GLConsumer clears the mCurrentTexture
+// when it is disconnected and reconnected. Otherwise it will
+// attempt to release a buffer that it does not owned
+TEST_F(SurfaceTextureGLTest, DisconnectClearsCurrentTexture) {
+ ASSERT_EQ(OK, native_window_api_connect(mANW.get(),
+ NATIVE_WINDOW_API_EGL));
+
+ ANativeWindowBuffer *anb;
+
+ EXPECT_EQ (OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb));
+ EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1));
+
+ EXPECT_EQ (OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb));
+ EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1));
+
+ EXPECT_EQ(OK,mST->updateTexImage());
+ EXPECT_EQ(OK,mST->updateTexImage());
+
+ ASSERT_EQ(OK, native_window_api_disconnect(mANW.get(),
+ NATIVE_WINDOW_API_EGL));
+ ASSERT_EQ(OK, native_window_api_connect(mANW.get(),
+ NATIVE_WINDOW_API_EGL));
+
+ EXPECT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb));
+ EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1));
+
+ // Will fail here if mCurrentTexture is not cleared properly
+ mFW->waitForFrame();
+ EXPECT_EQ(OK,mST->updateTexImage());
+
+ ASSERT_EQ(OK, native_window_api_disconnect(mANW.get(),
+ NATIVE_WINDOW_API_EGL));
+}
+
+TEST_F(SurfaceTextureGLTest, ScaleToWindowMode) {
+ ASSERT_EQ(OK, native_window_set_scaling_mode(mANW.get(),
+ NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW));
+
+ // The producer image size
+ ASSERT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 512, 512));
+
+ // The consumer image size (16 x 9) ratio
+ mST->setDefaultBufferSize(1280, 720);
+
+ ASSERT_EQ(OK, native_window_api_connect(mANW.get(),
+ NATIVE_WINDOW_API_CPU));
+
+ ANativeWindowBuffer *anb;
+
+ android_native_rect_t odd = {23, 78, 123, 477};
+ ASSERT_EQ(OK, native_window_set_crop(mANW.get(), &odd));
+ EXPECT_EQ (OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb));
+ EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1));
+ mFW->waitForFrame();
+ EXPECT_EQ(OK, mST->updateTexImage());
+ Rect r = mST->getCurrentCrop();
+ assertRectEq(Rect(23, 78, 123, 477), r);
+
+ ASSERT_EQ(OK, native_window_api_disconnect(mANW.get(),
+ NATIVE_WINDOW_API_CPU));
+}
+
+// This test ensures the scaling mode does the right thing
+// ie NATIVE_WINDOW_SCALING_MODE_CROP should crop
+// the image such that it has the same aspect ratio as the
+// default buffer size
+TEST_F(SurfaceTextureGLTest, CroppedScalingMode) {
+ ASSERT_EQ(OK, native_window_set_scaling_mode(mANW.get(),
+ NATIVE_WINDOW_SCALING_MODE_SCALE_CROP));
+
+ // The producer image size
+ ASSERT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 512, 512));
+
+ // The consumer image size (16 x 9) ratio
+ mST->setDefaultBufferSize(1280, 720);
+
+ native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU);
+
+ ANativeWindowBuffer *anb;
+
+ // The crop is in the shape of (320, 180) === 16 x 9
+ android_native_rect_t standard = {10, 20, 330, 200};
+ ASSERT_EQ(OK, native_window_set_crop(mANW.get(), &standard));
+ EXPECT_EQ (OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb));
+ EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1));
+ mFW->waitForFrame();
+ EXPECT_EQ(OK, mST->updateTexImage());
+ Rect r = mST->getCurrentCrop();
+ // crop should be the same as crop (same aspect ratio)
+ assertRectEq(Rect(10, 20, 330, 200), r);
+
+ // make this wider then desired aspect 239 x 100 (2.39:1)
+ android_native_rect_t wide = {20, 30, 259, 130};
+ ASSERT_EQ(OK, native_window_set_crop(mANW.get(), &wide));
+ EXPECT_EQ (OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb));
+ EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1));
+ mFW->waitForFrame();
+ EXPECT_EQ(OK, mST->updateTexImage());
+ r = mST->getCurrentCrop();
+ // crop should be the same height, but have cropped left and right borders
+ // offset is 30.6 px L+, R-
+ assertRectEq(Rect(51, 30, 228, 130), r);
+
+ // This image is taller then desired aspect 400 x 300 (4:3)
+ android_native_rect_t narrow = {0, 0, 400, 300};
+ ASSERT_EQ(OK, native_window_set_crop(mANW.get(), &narrow));
+ EXPECT_EQ (OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb));
+ EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1));
+ mFW->waitForFrame();
+ EXPECT_EQ(OK, mST->updateTexImage());
+ r = mST->getCurrentCrop();
+ // crop should be the same width, but have cropped top and bottom borders
+ // offset is 37.5 px
+ assertRectEq(Rect(0, 37, 400, 262), r);
+
+ native_window_api_disconnect(mANW.get(), NATIVE_WINDOW_API_CPU);
+}
+
+TEST_F(SurfaceTextureGLTest, AbandonUnblocksDequeueBuffer) {
+ class ProducerThread : public Thread {
+ public:
+ ProducerThread(const sp<ANativeWindow>& anw):
+ mANW(anw),
+ mDequeueError(NO_ERROR) {
+ }
+
+ virtual ~ProducerThread() {
+ }
+
+ virtual bool threadLoop() {
+ Mutex::Autolock lock(mMutex);
+ ANativeWindowBuffer* anb;
+
+ // Frame 1
+ if (native_window_dequeue_buffer_and_wait(mANW.get(),
+ &anb) != NO_ERROR) {
+ return false;
+ }
+ if (anb == NULL) {
+ return false;
+ }
+ if (mANW->queueBuffer(mANW.get(), anb, -1)
+ != NO_ERROR) {
+ return false;
+ }
+
+ // Frame 2
+ if (native_window_dequeue_buffer_and_wait(mANW.get(),
+ &anb) != NO_ERROR) {
+ return false;
+ }
+ if (anb == NULL) {
+ return false;
+ }
+ if (mANW->queueBuffer(mANW.get(), anb, -1)
+ != NO_ERROR) {
+ return false;
+ }
+
+ // Frame 3 - error expected
+ mDequeueError = native_window_dequeue_buffer_and_wait(mANW.get(),
+ &anb);
+ return false;
+ }
+
+ status_t getDequeueError() {
+ Mutex::Autolock lock(mMutex);
+ return mDequeueError;
+ }
+
+ private:
+ sp<ANativeWindow> mANW;
+ status_t mDequeueError;
+ Mutex mMutex;
+ };
+
+ ASSERT_EQ(OK, mST->setDefaultMaxBufferCount(2));
+
+ sp<Thread> pt(new ProducerThread(mANW));
+ pt->run();
+
+ mFW->waitForFrame();
+ mFW->waitForFrame();
+
+ // Sleep for 100ms to allow the producer thread's dequeueBuffer call to
+ // block waiting for a buffer to become available.
+ usleep(100000);
+
+ mST->abandon();
+
+ pt->requestExitAndWait();
+ ASSERT_EQ(NO_INIT,
+ reinterpret_cast<ProducerThread*>(pt.get())->getDequeueError());
+}
+
+TEST_F(SurfaceTextureGLTest, InvalidWidthOrHeightFails) {
+ int texHeight = 16;
+ ANativeWindowBuffer* anb;
+
+ GLint maxTextureSize;
+ glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
+
+ // make sure it works with small textures
+ mST->setDefaultBufferSize(16, texHeight);
+ EXPECT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(),
+ &anb));
+ EXPECT_EQ(16, anb->width);
+ EXPECT_EQ(texHeight, anb->height);
+ EXPECT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), anb, -1));
+ EXPECT_EQ(NO_ERROR, mST->updateTexImage());
+
+ // make sure it works with GL_MAX_TEXTURE_SIZE
+ mST->setDefaultBufferSize(maxTextureSize, texHeight);
+ EXPECT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(),
+ &anb));
+ EXPECT_EQ(maxTextureSize, anb->width);
+ EXPECT_EQ(texHeight, anb->height);
+ EXPECT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), anb, -1));
+ EXPECT_EQ(NO_ERROR, mST->updateTexImage());
+
+ // make sure it fails with GL_MAX_TEXTURE_SIZE+1
+ mST->setDefaultBufferSize(maxTextureSize+1, texHeight);
+ EXPECT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(),
+ &anb));
+ EXPECT_EQ(maxTextureSize+1, anb->width);
+ EXPECT_EQ(texHeight, anb->height);
+ EXPECT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), anb, -1));
+ ASSERT_NE(NO_ERROR, mST->updateTexImage());
+}
+
+} // namespace android
diff --git a/libs/gui/tests/SurfaceTextureMultiContextGL.h b/libs/gui/tests/SurfaceTextureMultiContextGL.h
new file mode 100644
index 0000000..7934bbc
--- /dev/null
+++ b/libs/gui/tests/SurfaceTextureMultiContextGL.h
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_SURFACE_TEXTURE_MULTI_CONTEXT_GL_H
+#define ANDROID_SURFACE_TEXTURE_MULTI_CONTEXT_GL_H
+
+#include "SurfaceTextureGL.h"
+
+namespace android {
+
+class SurfaceTextureMultiContextGLTest : public SurfaceTextureGLTest {
+protected:
+ enum { SECOND_TEX_ID = 123 };
+ enum { THIRD_TEX_ID = 456 };
+
+ SurfaceTextureMultiContextGLTest():
+ mSecondEglContext(EGL_NO_CONTEXT) {
+ }
+
+ virtual void SetUp() {
+ SurfaceTextureGLTest::SetUp();
+
+ // Set up the secondary context and texture renderer.
+ mSecondEglContext = eglCreateContext(mEglDisplay, mGlConfig,
+ EGL_NO_CONTEXT, getContextAttribs());
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ ASSERT_NE(EGL_NO_CONTEXT, mSecondEglContext);
+
+ ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
+ mSecondEglContext));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ mSecondTextureRenderer = new TextureRenderer(SECOND_TEX_ID, mST);
+ ASSERT_NO_FATAL_FAILURE(mSecondTextureRenderer->SetUp());
+
+ // Set up the tertiary context and texture renderer.
+ mThirdEglContext = eglCreateContext(mEglDisplay, mGlConfig,
+ EGL_NO_CONTEXT, getContextAttribs());
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ ASSERT_NE(EGL_NO_CONTEXT, mThirdEglContext);
+
+ ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
+ mThirdEglContext));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ mThirdTextureRenderer = new TextureRenderer(THIRD_TEX_ID, mST);
+ ASSERT_NO_FATAL_FAILURE(mThirdTextureRenderer->SetUp());
+
+ // Switch back to the primary context to start the tests.
+ ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
+ mEglContext));
+ }
+
+ virtual void TearDown() {
+ if (mThirdEglContext != EGL_NO_CONTEXT) {
+ eglDestroyContext(mEglDisplay, mThirdEglContext);
+ }
+ if (mSecondEglContext != EGL_NO_CONTEXT) {
+ eglDestroyContext(mEglDisplay, mSecondEglContext);
+ }
+ SurfaceTextureGLTest::TearDown();
+ }
+
+ EGLContext mSecondEglContext;
+ sp<TextureRenderer> mSecondTextureRenderer;
+
+ EGLContext mThirdEglContext;
+ sp<TextureRenderer> mThirdTextureRenderer;
+};
+
+}
+
+#endif
diff --git a/libs/gui/tests/SurfaceTextureMultiContextGL_test.cpp b/libs/gui/tests/SurfaceTextureMultiContextGL_test.cpp
new file mode 100644
index 0000000..115a47d
--- /dev/null
+++ b/libs/gui/tests/SurfaceTextureMultiContextGL_test.cpp
@@ -0,0 +1,389 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "SurfaceTextureMultiContextGL_test"
+//#define LOG_NDEBUG 0
+
+#include "SurfaceTextureMultiContextGL.h"
+
+#include "FillBuffer.h"
+
+#include <GLES/glext.h>
+
+namespace android {
+
+TEST_F(SurfaceTextureMultiContextGLTest, UpdateFromMultipleContextsFails) {
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+
+ // Latch the texture contents on the primary context.
+ mFW->waitForFrame();
+ ASSERT_EQ(OK, mST->updateTexImage());
+
+ // Attempt to latch the texture on the secondary context.
+ ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
+ mSecondEglContext));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+ ASSERT_EQ(INVALID_OPERATION, mST->updateTexImage());
+}
+
+TEST_F(SurfaceTextureMultiContextGLTest, DetachFromContextSucceeds) {
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+
+ // Latch the texture contents on the primary context.
+ mFW->waitForFrame();
+ ASSERT_EQ(OK, mST->updateTexImage());
+
+ // Detach from the primary context.
+ ASSERT_EQ(OK, mST->detachFromContext());
+
+ // Check that the GL texture was deleted.
+ EXPECT_EQ(GL_FALSE, glIsTexture(TEX_ID));
+}
+
+TEST_F(SurfaceTextureMultiContextGLTest,
+ DetachFromContextSucceedsAfterProducerDisconnect) {
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+
+ // Latch the texture contents on the primary context.
+ mFW->waitForFrame();
+ ASSERT_EQ(OK, mST->updateTexImage());
+
+ // Detach from the primary context.
+ native_window_api_disconnect(mANW.get(), NATIVE_WINDOW_API_CPU);
+ ASSERT_EQ(OK, mST->detachFromContext());
+
+ // Check that the GL texture was deleted.
+ EXPECT_EQ(GL_FALSE, glIsTexture(TEX_ID));
+}
+
+TEST_F(SurfaceTextureMultiContextGLTest, DetachFromContextFailsWhenAbandoned) {
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+
+ // Latch the texture contents on the primary context.
+ mFW->waitForFrame();
+ ASSERT_EQ(OK, mST->updateTexImage());
+
+ // Attempt to detach from the primary context.
+ mST->abandon();
+ ASSERT_EQ(NO_INIT, mST->detachFromContext());
+}
+
+TEST_F(SurfaceTextureMultiContextGLTest, DetachFromContextFailsWhenDetached) {
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+
+ // Latch the texture contents on the primary context.
+ mFW->waitForFrame();
+ ASSERT_EQ(OK, mST->updateTexImage());
+
+ // Detach from the primary context.
+ ASSERT_EQ(OK, mST->detachFromContext());
+
+ // Attempt to detach from the primary context again.
+ ASSERT_EQ(INVALID_OPERATION, mST->detachFromContext());
+}
+
+TEST_F(SurfaceTextureMultiContextGLTest, DetachFromContextFailsWithNoDisplay) {
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+
+ // Latch the texture contents on the primary context.
+ mFW->waitForFrame();
+ ASSERT_EQ(OK, mST->updateTexImage());
+
+ // Make there be no current display.
+ ASSERT_TRUE(eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
+ EGL_NO_CONTEXT));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+
+ // Attempt to detach from the primary context.
+ ASSERT_EQ(INVALID_OPERATION, mST->detachFromContext());
+}
+
+TEST_F(SurfaceTextureMultiContextGLTest, DetachFromContextFailsWithNoContext) {
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+
+ // Latch the texture contents on the primary context.
+ mFW->waitForFrame();
+ ASSERT_EQ(OK, mST->updateTexImage());
+
+ // Make current context be incorrect.
+ ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
+ mSecondEglContext));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+
+ // Attempt to detach from the primary context.
+ ASSERT_EQ(INVALID_OPERATION, mST->detachFromContext());
+}
+
+TEST_F(SurfaceTextureMultiContextGLTest, UpdateTexImageFailsWhenDetached) {
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+
+ // Detach from the primary context.
+ ASSERT_EQ(OK, mST->detachFromContext());
+
+ // Attempt to latch the texture contents on the primary context.
+ mFW->waitForFrame();
+ ASSERT_EQ(INVALID_OPERATION, mST->updateTexImage());
+}
+
+TEST_F(SurfaceTextureMultiContextGLTest, AttachToContextSucceeds) {
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+
+ // Latch the texture contents on the primary context.
+ mFW->waitForFrame();
+ ASSERT_EQ(OK, mST->updateTexImage());
+
+ // Detach from the primary context.
+ ASSERT_EQ(OK, mST->detachFromContext());
+
+ // Attach to the secondary context.
+ ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
+ mSecondEglContext));
+ ASSERT_EQ(OK, mST->attachToContext(SECOND_TEX_ID));
+
+ // Verify that the texture object was created and bound.
+ GLint texBinding = -1;
+ glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, &texBinding);
+ EXPECT_EQ(SECOND_TEX_ID, texBinding);
+
+ // Try to use the texture from the secondary context.
+ glClearColor(0.2, 0.2, 0.2, 0.2);
+ glClear(GL_COLOR_BUFFER_BIT);
+ glViewport(0, 0, 1, 1);
+ mSecondTextureRenderer->drawTexture();
+ ASSERT_TRUE(checkPixel( 0, 0, 35, 35, 35, 35));
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+}
+
+TEST_F(SurfaceTextureMultiContextGLTest,
+ AttachToContextSucceedsAfterProducerDisconnect) {
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+
+ // Latch the texture contents on the primary context.
+ mFW->waitForFrame();
+ ASSERT_EQ(OK, mST->updateTexImage());
+
+ // Detach from the primary context.
+ native_window_api_disconnect(mANW.get(), NATIVE_WINDOW_API_CPU);
+ ASSERT_EQ(OK, mST->detachFromContext());
+
+ // Attach to the secondary context.
+ ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
+ mSecondEglContext));
+ ASSERT_EQ(OK, mST->attachToContext(SECOND_TEX_ID));
+
+ // Verify that the texture object was created and bound.
+ GLint texBinding = -1;
+ glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, &texBinding);
+ EXPECT_EQ(SECOND_TEX_ID, texBinding);
+
+ // Try to use the texture from the secondary context.
+ glClearColor(0.2, 0.2, 0.2, 0.2);
+ glClear(GL_COLOR_BUFFER_BIT);
+ glViewport(0, 0, 1, 1);
+ mSecondTextureRenderer->drawTexture();
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+ ASSERT_TRUE(checkPixel( 0, 0, 35, 35, 35, 35));
+}
+
+TEST_F(SurfaceTextureMultiContextGLTest,
+ AttachToContextSucceedsBeforeUpdateTexImage) {
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+
+ // Detach from the primary context.
+ native_window_api_disconnect(mANW.get(), NATIVE_WINDOW_API_CPU);
+ ASSERT_EQ(OK, mST->detachFromContext());
+
+ // Attach to the secondary context.
+ ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
+ mSecondEglContext));
+ ASSERT_EQ(OK, mST->attachToContext(SECOND_TEX_ID));
+
+ // Verify that the texture object was created and bound.
+ GLint texBinding = -1;
+ glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, &texBinding);
+ EXPECT_EQ(SECOND_TEX_ID, texBinding);
+
+ // Latch the texture contents on the primary context.
+ mFW->waitForFrame();
+ ASSERT_EQ(OK, mST->updateTexImage());
+
+ // Try to use the texture from the secondary context.
+ glClearColor(0.2, 0.2, 0.2, 0.2);
+ glClear(GL_COLOR_BUFFER_BIT);
+ glViewport(0, 0, 1, 1);
+ mSecondTextureRenderer->drawTexture();
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+ ASSERT_TRUE(checkPixel( 0, 0, 35, 35, 35, 35));
+}
+
+TEST_F(SurfaceTextureMultiContextGLTest, AttachToContextFailsWhenAbandoned) {
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+
+ // Latch the texture contents on the primary context.
+ mFW->waitForFrame();
+ ASSERT_EQ(OK, mST->updateTexImage());
+
+ // Detach from the primary context.
+ ASSERT_EQ(OK, mST->detachFromContext());
+
+ // Attempt to attach to the secondary context.
+ mST->abandon();
+
+ // Attempt to attach to the primary context.
+ ASSERT_EQ(NO_INIT, mST->attachToContext(SECOND_TEX_ID));
+}
+
+TEST_F(SurfaceTextureMultiContextGLTest, AttachToContextFailsWhenAttached) {
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+
+ // Latch the texture contents on the primary context.
+ mFW->waitForFrame();
+ ASSERT_EQ(OK, mST->updateTexImage());
+
+ // Attempt to attach to the primary context.
+ ASSERT_EQ(INVALID_OPERATION, mST->attachToContext(SECOND_TEX_ID));
+}
+
+TEST_F(SurfaceTextureMultiContextGLTest,
+ AttachToContextFailsWhenAttachedBeforeUpdateTexImage) {
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+
+ // Attempt to attach to the primary context.
+ ASSERT_EQ(INVALID_OPERATION, mST->attachToContext(SECOND_TEX_ID));
+}
+
+TEST_F(SurfaceTextureMultiContextGLTest, AttachToContextFailsWithNoDisplay) {
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+
+ // Latch the texture contents on the primary context.
+ mFW->waitForFrame();
+ ASSERT_EQ(OK, mST->updateTexImage());
+
+ // Detach from the primary context.
+ ASSERT_EQ(OK, mST->detachFromContext());
+
+ // Make there be no current display.
+ ASSERT_TRUE(eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
+ EGL_NO_CONTEXT));
+ ASSERT_EQ(EGL_SUCCESS, eglGetError());
+
+ // Attempt to attach with no context current.
+ ASSERT_EQ(INVALID_OPERATION, mST->attachToContext(SECOND_TEX_ID));
+}
+
+TEST_F(SurfaceTextureMultiContextGLTest, AttachToContextSucceedsTwice) {
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+
+ // Latch the texture contents on the primary context.
+ mFW->waitForFrame();
+ ASSERT_EQ(OK, mST->updateTexImage());
+
+ // Detach from the primary context.
+ ASSERT_EQ(OK, mST->detachFromContext());
+
+ // Attach to the secondary context.
+ ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
+ mSecondEglContext));
+ ASSERT_EQ(OK, mST->attachToContext(SECOND_TEX_ID));
+
+ // Detach from the secondary context.
+ ASSERT_EQ(OK, mST->detachFromContext());
+
+ // Attach to the tertiary context.
+ ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
+ mThirdEglContext));
+ ASSERT_EQ(OK, mST->attachToContext(THIRD_TEX_ID));
+
+ // Verify that the texture object was created and bound.
+ GLint texBinding = -1;
+ glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, &texBinding);
+ EXPECT_EQ(THIRD_TEX_ID, texBinding);
+
+ // Try to use the texture from the tertiary context.
+ glClearColor(0.2, 0.2, 0.2, 0.2);
+ glClear(GL_COLOR_BUFFER_BIT);
+ glViewport(0, 0, 1, 1);
+ mThirdTextureRenderer->drawTexture();
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+ ASSERT_TRUE(checkPixel( 0, 0, 35, 35, 35, 35));
+}
+
+TEST_F(SurfaceTextureMultiContextGLTest,
+ AttachToContextSucceedsTwiceBeforeUpdateTexImage) {
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+
+ // Detach from the primary context.
+ ASSERT_EQ(OK, mST->detachFromContext());
+
+ // Attach to the secondary context.
+ ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
+ mSecondEglContext));
+ ASSERT_EQ(OK, mST->attachToContext(SECOND_TEX_ID));
+
+ // Detach from the secondary context.
+ ASSERT_EQ(OK, mST->detachFromContext());
+
+ // Attach to the tertiary context.
+ ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
+ mThirdEglContext));
+ ASSERT_EQ(OK, mST->attachToContext(THIRD_TEX_ID));
+
+ // Verify that the texture object was created and bound.
+ GLint texBinding = -1;
+ glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, &texBinding);
+ EXPECT_EQ(THIRD_TEX_ID, texBinding);
+
+ // Latch the texture contents on the tertiary context.
+ mFW->waitForFrame();
+ ASSERT_EQ(OK, mST->updateTexImage());
+
+ // Try to use the texture from the tertiary context.
+ glClearColor(0.2, 0.2, 0.2, 0.2);
+ glClear(GL_COLOR_BUFFER_BIT);
+ glViewport(0, 0, 1, 1);
+ mThirdTextureRenderer->drawTexture();
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+ ASSERT_TRUE(checkPixel( 0, 0, 35, 35, 35, 35));
+}
+
+TEST_F(SurfaceTextureMultiContextGLTest,
+ UpdateTexImageSucceedsForBufferConsumedBeforeDetach) {
+ ASSERT_EQ(NO_ERROR, mST->setDefaultMaxBufferCount(2));
+
+ // produce two frames and consume them both on the primary context
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+ mFW->waitForFrame();
+ ASSERT_EQ(OK, mST->updateTexImage());
+
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+ mFW->waitForFrame();
+ ASSERT_EQ(OK, mST->updateTexImage());
+
+ // produce one more frame
+ ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
+
+ // Detach from the primary context and attach to the secondary context
+ ASSERT_EQ(OK, mST->detachFromContext());
+ ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
+ mSecondEglContext));
+ ASSERT_EQ(OK, mST->attachToContext(SECOND_TEX_ID));
+
+ // Consume final frame on secondary context
+ mFW->waitForFrame();
+ ASSERT_EQ(OK, mST->updateTexImage());
+}
+
+} // namespace android
diff --git a/libs/gui/tests/SurfaceTexture_test.cpp b/libs/gui/tests/SurfaceTexture_test.cpp
deleted file mode 100644
index fd18ad2..0000000
--- a/libs/gui/tests/SurfaceTexture_test.cpp
+++ /dev/null
@@ -1,2477 +0,0 @@
-/*
- * Copyright (C) 2011 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#define LOG_TAG "SurfaceTexture_test"
-//#define LOG_NDEBUG 0
-
-#include "GLTest.h"
-
-#include <gui/GLConsumer.h>
-#include <ui/GraphicBuffer.h>
-#include <utils/String8.h>
-#include <utils/threads.h>
-
-#include <gui/ISurfaceComposer.h>
-#include <gui/Surface.h>
-
-#include <EGL/eglext.h>
-#include <GLES/glext.h>
-#include <GLES2/gl2.h>
-#include <GLES2/gl2ext.h>
-
-#include <ui/FramebufferNativeWindow.h>
-#include <UniquePtr.h>
-#include <android/native_window.h>
-
-namespace android {
-
-class MultiTextureConsumerTest : public GLTest {
-protected:
- enum { TEX_ID = 123 };
-
- virtual void SetUp() {
- GLTest::SetUp();
- sp<BufferQueue> bq = new BufferQueue();
- mGlConsumer = new GLConsumer(bq, TEX_ID);
- mSurface = new Surface(bq);
- mANW = mSurface.get();
-
- }
- virtual void TearDown() {
- GLTest::TearDown();
- }
- virtual EGLint const* getContextAttribs() {
- return NULL;
- }
- virtual EGLint const* getConfigAttribs() {
- static EGLint sDefaultConfigAttribs[] = {
- EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
- EGL_RED_SIZE, 8,
- EGL_GREEN_SIZE, 8,
- EGL_BLUE_SIZE, 8,
- EGL_ALPHA_SIZE, 8,
- EGL_NONE };
-
- return sDefaultConfigAttribs;
- }
- sp<GLConsumer> mGlConsumer;
- sp<Surface> mSurface;
- ANativeWindow* mANW;
-};
-
-
-TEST_F(MultiTextureConsumerTest, EGLImageTargetWorks) {
- ANativeWindow_Buffer buffer;
-
- ASSERT_EQ(native_window_set_usage(mANW, GRALLOC_USAGE_SW_WRITE_OFTEN), NO_ERROR);
- ASSERT_EQ(native_window_set_buffers_format(mANW, HAL_PIXEL_FORMAT_RGBA_8888), NO_ERROR);
-
- glShadeModel(GL_FLAT);
- glDisable(GL_DITHER);
- glDisable(GL_CULL_FACE);
- glViewport(0, 0, getSurfaceWidth(), getSurfaceHeight());
- glOrthof(0, getSurfaceWidth(), 0, getSurfaceHeight(), 0, 1);
- glEnableClientState(GL_VERTEX_ARRAY);
- glColor4f(1, 1, 1, 1);
-
- glBindTexture(GL_TEXTURE_EXTERNAL_OES, TEX_ID);
- glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
- glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
- glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
- glTexParameterx(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-
- uint32_t texel = 0x80808080;
- glBindTexture(GL_TEXTURE_2D, TEX_ID+1);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, &texel);
- glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
- glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
- glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
- glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-
- glActiveTexture(GL_TEXTURE1);
- glBindTexture(GL_TEXTURE_2D, TEX_ID+1);
- glEnable(GL_TEXTURE_2D);
- glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-
- glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_EXTERNAL_OES, TEX_ID);
- glEnable(GL_TEXTURE_EXTERNAL_OES);
- glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-
- glClear(GL_COLOR_BUFFER_BIT);
- for (int i=0 ; i<8 ; i++) {
- mSurface->lock(&buffer, NULL);
- memset(buffer.bits, (i&7) * 0x20, buffer.stride * buffer.height * 4);
- mSurface->unlockAndPost();
-
- mGlConsumer->updateTexImage();
-
- GLfloat vertices[][2] = { {i*16.0f, 0}, {(i+1)*16.0f, 0}, {(i+1)*16.0f, 16.0f}, {i*16.0f, 16.0f} };
- glVertexPointer(2, GL_FLOAT, 0, vertices);
- glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
-
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
- }
-
- for (int i=0 ; i<8 ; i++) {
- EXPECT_TRUE(checkPixel(i*16 + 8, 8, i*16, i*16, i*16, i*16, 0));
- }
-}
-
-
-
-class SurfaceTextureGLTest : public GLTest {
-protected:
- enum { TEX_ID = 123 };
-
- virtual void SetUp() {
- GLTest::SetUp();
- sp<BufferQueue> bq = new BufferQueue();
- mBQ = bq;
- mST = new GLConsumer(bq, TEX_ID);
- mSTC = new Surface(bq);
- mANW = mSTC;
- mTextureRenderer = new TextureRenderer(TEX_ID, mST);
- ASSERT_NO_FATAL_FAILURE(mTextureRenderer->SetUp());
- mFW = new FrameWaiter;
- mST->setFrameAvailableListener(mFW);
- }
-
- virtual void TearDown() {
- mTextureRenderer.clear();
- mANW.clear();
- mSTC.clear();
- mST.clear();
- GLTest::TearDown();
- }
-
- void drawTexture() {
- mTextureRenderer->drawTexture();
- }
-
- class TextureRenderer: public RefBase {
- public:
- TextureRenderer(GLuint texName, const sp<GLConsumer>& st):
- mTexName(texName),
- mST(st) {
- }
-
- void SetUp() {
- const char vsrc[] =
- "attribute vec4 vPosition;\n"
- "varying vec2 texCoords;\n"
- "uniform mat4 texMatrix;\n"
- "void main() {\n"
- " vec2 vTexCoords = 0.5 * (vPosition.xy + vec2(1.0, 1.0));\n"
- " texCoords = (texMatrix * vec4(vTexCoords, 0.0, 1.0)).xy;\n"
- " gl_Position = vPosition;\n"
- "}\n";
-
- const char fsrc[] =
- "#extension GL_OES_EGL_image_external : require\n"
- "precision mediump float;\n"
- "uniform samplerExternalOES texSampler;\n"
- "varying vec2 texCoords;\n"
- "void main() {\n"
- " gl_FragColor = texture2D(texSampler, texCoords);\n"
- "}\n";
-
- {
- SCOPED_TRACE("creating shader program");
- ASSERT_NO_FATAL_FAILURE(createProgram(vsrc, fsrc, &mPgm));
- }
-
- mPositionHandle = glGetAttribLocation(mPgm, "vPosition");
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
- ASSERT_NE(-1, mPositionHandle);
- mTexSamplerHandle = glGetUniformLocation(mPgm, "texSampler");
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
- ASSERT_NE(-1, mTexSamplerHandle);
- mTexMatrixHandle = glGetUniformLocation(mPgm, "texMatrix");
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
- ASSERT_NE(-1, mTexMatrixHandle);
- }
-
- // drawTexture draws the GLConsumer over the entire GL viewport.
- void drawTexture() {
- static const GLfloat triangleVertices[] = {
- -1.0f, 1.0f,
- -1.0f, -1.0f,
- 1.0f, -1.0f,
- 1.0f, 1.0f,
- };
-
- glVertexAttribPointer(mPositionHandle, 2, GL_FLOAT, GL_FALSE, 0,
- triangleVertices);
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
- glEnableVertexAttribArray(mPositionHandle);
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
-
- glUseProgram(mPgm);
- glUniform1i(mTexSamplerHandle, 0);
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
- glBindTexture(GL_TEXTURE_EXTERNAL_OES, mTexName);
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
-
- // XXX: These calls are not needed for GL_TEXTURE_EXTERNAL_OES as
- // they're setting the defautls for that target, but when hacking
- // things to use GL_TEXTURE_2D they are needed to achieve the same
- // behavior.
- glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER,
- GL_LINEAR);
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
- glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER,
- GL_LINEAR);
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
- glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S,
- GL_CLAMP_TO_EDGE);
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
- glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T,
- GL_CLAMP_TO_EDGE);
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
-
- GLfloat texMatrix[16];
- mST->getTransformMatrix(texMatrix);
- glUniformMatrix4fv(mTexMatrixHandle, 1, GL_FALSE, texMatrix);
-
- glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
- }
-
- GLuint mTexName;
- sp<GLConsumer> mST;
- GLuint mPgm;
- GLint mPositionHandle;
- GLint mTexSamplerHandle;
- GLint mTexMatrixHandle;
- };
-
- class FrameWaiter : public GLConsumer::FrameAvailableListener {
- public:
- FrameWaiter():
- mPendingFrames(0) {
- }
-
- void waitForFrame() {
- Mutex::Autolock lock(mMutex);
- while (mPendingFrames == 0) {
- mCondition.wait(mMutex);
- }
- mPendingFrames--;
- }
-
- virtual void onFrameAvailable() {
- Mutex::Autolock lock(mMutex);
- mPendingFrames++;
- mCondition.signal();
- }
-
- int mPendingFrames;
- Mutex mMutex;
- Condition mCondition;
- };
-
- // Note that GLConsumer will lose the notifications
- // onBuffersReleased and onFrameAvailable as there is currently
- // no way to forward the events. This DisconnectWaiter will not let the
- // disconnect finish until finishDisconnect() is called. It will
- // also block until a disconnect is called
- class DisconnectWaiter : public BnConsumerListener {
- public:
- DisconnectWaiter () :
- mWaitForDisconnect(false),
- mPendingFrames(0) {
- }
-
- void waitForFrame() {
- Mutex::Autolock lock(mMutex);
- while (mPendingFrames == 0) {
- mFrameCondition.wait(mMutex);
- }
- mPendingFrames--;
- }
-
- virtual void onFrameAvailable() {
- Mutex::Autolock lock(mMutex);
- mPendingFrames++;
- mFrameCondition.signal();
- }
-
- virtual void onBuffersReleased() {
- Mutex::Autolock lock(mMutex);
- while (!mWaitForDisconnect) {
- mDisconnectCondition.wait(mMutex);
- }
- }
-
- void finishDisconnect() {
- Mutex::Autolock lock(mMutex);
- mWaitForDisconnect = true;
- mDisconnectCondition.signal();
- }
-
- private:
- Mutex mMutex;
-
- bool mWaitForDisconnect;
- Condition mDisconnectCondition;
-
- int mPendingFrames;
- Condition mFrameCondition;
- };
-
- sp<BufferQueue> mBQ;
- sp<GLConsumer> mST;
- sp<Surface> mSTC;
- sp<ANativeWindow> mANW;
- sp<TextureRenderer> mTextureRenderer;
- sp<FrameWaiter> mFW;
-};
-
-// Fill a YV12 buffer with a multi-colored checkerboard pattern
-void fillYV12Buffer(uint8_t* buf, int w, int h, int stride) {
- const int blockWidth = w > 16 ? w / 16 : 1;
- const int blockHeight = h > 16 ? h / 16 : 1;
- const int yuvTexOffsetY = 0;
- int yuvTexStrideY = stride;
- int yuvTexOffsetV = yuvTexStrideY * h;
- int yuvTexStrideV = (yuvTexStrideY/2 + 0xf) & ~0xf;
- int yuvTexOffsetU = yuvTexOffsetV + yuvTexStrideV * h/2;
- int yuvTexStrideU = yuvTexStrideV;
- for (int x = 0; x < w; x++) {
- for (int y = 0; y < h; y++) {
- int parityX = (x / blockWidth) & 1;
- int parityY = (y / blockHeight) & 1;
- unsigned char intensity = (parityX ^ parityY) ? 63 : 191;
- buf[yuvTexOffsetY + (y * yuvTexStrideY) + x] = intensity;
- if (x < w / 2 && y < h / 2) {
- buf[yuvTexOffsetU + (y * yuvTexStrideU) + x] = intensity;
- if (x * 2 < w / 2 && y * 2 < h / 2) {
- buf[yuvTexOffsetV + (y*2 * yuvTexStrideV) + x*2 + 0] =
- buf[yuvTexOffsetV + (y*2 * yuvTexStrideV) + x*2 + 1] =
- buf[yuvTexOffsetV + ((y*2+1) * yuvTexStrideV) + x*2 + 0] =
- buf[yuvTexOffsetV + ((y*2+1) * yuvTexStrideV) + x*2 + 1] =
- intensity;
- }
- }
- }
- }
-}
-
-// Fill a YV12 buffer with red outside a given rectangle and green inside it.
-void fillYV12BufferRect(uint8_t* buf, int w, int h, int stride,
- const android_native_rect_t& rect) {
- const int yuvTexOffsetY = 0;
- int yuvTexStrideY = stride;
- int yuvTexOffsetV = yuvTexStrideY * h;
- int yuvTexStrideV = (yuvTexStrideY/2 + 0xf) & ~0xf;
- int yuvTexOffsetU = yuvTexOffsetV + yuvTexStrideV * h/2;
- int yuvTexStrideU = yuvTexStrideV;
- for (int x = 0; x < w; x++) {
- for (int y = 0; y < h; y++) {
- bool inside = rect.left <= x && x < rect.right &&
- rect.top <= y && y < rect.bottom;
- buf[yuvTexOffsetY + (y * yuvTexStrideY) + x] = inside ? 240 : 64;
- if (x < w / 2 && y < h / 2) {
- bool inside = rect.left <= 2*x && 2*x < rect.right &&
- rect.top <= 2*y && 2*y < rect.bottom;
- buf[yuvTexOffsetU + (y * yuvTexStrideU) + x] = 16;
- buf[yuvTexOffsetV + (y * yuvTexStrideV) + x] =
- inside ? 16 : 255;
- }
- }
- }
-}
-
-void fillRGBA8Buffer(uint8_t* buf, int w, int h, int stride) {
- const size_t PIXEL_SIZE = 4;
- for (int x = 0; x < w; x++) {
- for (int y = 0; y < h; y++) {
- off_t offset = (y * stride + x) * PIXEL_SIZE;
- for (int c = 0; c < 4; c++) {
- int parityX = (x / (1 << (c+2))) & 1;
- int parityY = (y / (1 << (c+2))) & 1;
- buf[offset + c] = (parityX ^ parityY) ? 231 : 35;
- }
- }
- }
-}
-
-void fillRGBA8BufferSolid(uint8_t* buf, int w, int h, int stride,
- uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
- const size_t PIXEL_SIZE = 4;
- for (int y = 0; y < h; y++) {
- for (int x = 0; x < w; x++) {
- off_t offset = (y * stride + x) * PIXEL_SIZE;
- buf[offset + 0] = r;
- buf[offset + 1] = g;
- buf[offset + 2] = b;
- buf[offset + 3] = a;
- }
- }
-}
-
-// Produce a single RGBA8 frame by filling a buffer with a checkerboard pattern
-// using the CPU. This assumes that the ANativeWindow is already configured to
-// allow this to be done (e.g. the format is set to RGBA8).
-//
-// Calls to this function should be wrapped in an ASSERT_NO_FATAL_FAILURE().
-void produceOneRGBA8Frame(const sp<ANativeWindow>& anw) {
- android_native_buffer_t* anb;
- ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(),
- &anb));
- ASSERT_TRUE(anb != NULL);
-
- sp<GraphicBuffer> buf(new GraphicBuffer(anb, false));
-
- uint8_t* img = NULL;
- ASSERT_EQ(NO_ERROR, buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN,
- (void**)(&img)));
- fillRGBA8Buffer(img, buf->getWidth(), buf->getHeight(), buf->getStride());
- ASSERT_EQ(NO_ERROR, buf->unlock());
- ASSERT_EQ(NO_ERROR, anw->queueBuffer(anw.get(), buf->getNativeBuffer(),
- -1));
-}
-
-TEST_F(SurfaceTextureGLTest, TexturingFromCpuFilledYV12BufferNpot) {
- const int texWidth = 64;
- const int texHeight = 66;
-
- ASSERT_EQ(NO_ERROR, native_window_set_buffers_geometry(mANW.get(),
- texWidth, texHeight, HAL_PIXEL_FORMAT_YV12));
- ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(),
- GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN));
-
- ANativeWindowBuffer* anb;
- ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(),
- &anb));
- ASSERT_TRUE(anb != NULL);
-
- sp<GraphicBuffer> buf(new GraphicBuffer(anb, false));
-
- // Fill the buffer with the a checkerboard pattern
- uint8_t* img = NULL;
- buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img));
- fillYV12Buffer(img, texWidth, texHeight, buf->getStride());
- buf->unlock();
- ASSERT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), buf->getNativeBuffer(),
- -1));
-
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
-
- glClearColor(0.2, 0.2, 0.2, 0.2);
- glClear(GL_COLOR_BUFFER_BIT);
-
- glViewport(0, 0, texWidth, texHeight);
- drawTexture();
-
- EXPECT_TRUE(checkPixel( 0, 0, 255, 127, 255, 255, 3));
- EXPECT_TRUE(checkPixel(63, 0, 0, 133, 0, 255, 3));
- EXPECT_TRUE(checkPixel(63, 65, 0, 133, 0, 255, 3));
- EXPECT_TRUE(checkPixel( 0, 65, 255, 127, 255, 255, 3));
-
- EXPECT_TRUE(checkPixel(22, 44, 255, 127, 255, 255, 3));
- EXPECT_TRUE(checkPixel(45, 52, 255, 127, 255, 255, 3));
- EXPECT_TRUE(checkPixel(52, 51, 98, 255, 73, 255, 3));
- EXPECT_TRUE(checkPixel( 7, 31, 155, 0, 118, 255, 3));
- EXPECT_TRUE(checkPixel(31, 9, 107, 24, 87, 255, 3));
- EXPECT_TRUE(checkPixel(29, 35, 255, 127, 255, 255, 3));
- EXPECT_TRUE(checkPixel(36, 22, 155, 29, 0, 255, 3));
-}
-
-TEST_F(SurfaceTextureGLTest, TexturingFromCpuFilledYV12BufferPow2) {
- const int texWidth = 64;
- const int texHeight = 64;
-
- ASSERT_EQ(NO_ERROR, native_window_set_buffers_geometry(mANW.get(),
- texWidth, texHeight, HAL_PIXEL_FORMAT_YV12));
- ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(),
- GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN));
-
- ANativeWindowBuffer* anb;
- ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(),
- &anb));
- ASSERT_TRUE(anb != NULL);
-
- sp<GraphicBuffer> buf(new GraphicBuffer(anb, false));
-
- // Fill the buffer with the a checkerboard pattern
- uint8_t* img = NULL;
- buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img));
- fillYV12Buffer(img, texWidth, texHeight, buf->getStride());
- buf->unlock();
- ASSERT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), buf->getNativeBuffer(),
- -1));
-
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
-
- glClearColor(0.2, 0.2, 0.2, 0.2);
- glClear(GL_COLOR_BUFFER_BIT);
-
- glViewport(0, 0, texWidth, texHeight);
- drawTexture();
-
- EXPECT_TRUE(checkPixel( 0, 0, 0, 133, 0, 255));
- EXPECT_TRUE(checkPixel(63, 0, 255, 127, 255, 255));
- EXPECT_TRUE(checkPixel(63, 63, 0, 133, 0, 255));
- EXPECT_TRUE(checkPixel( 0, 63, 255, 127, 255, 255));
-
- EXPECT_TRUE(checkPixel(22, 19, 100, 255, 74, 255));
- EXPECT_TRUE(checkPixel(45, 11, 100, 255, 74, 255));
- EXPECT_TRUE(checkPixel(52, 12, 155, 0, 181, 255));
- EXPECT_TRUE(checkPixel( 7, 32, 150, 237, 170, 255));
- EXPECT_TRUE(checkPixel(31, 54, 0, 71, 117, 255));
- EXPECT_TRUE(checkPixel(29, 28, 0, 133, 0, 255));
- EXPECT_TRUE(checkPixel(36, 41, 100, 232, 255, 255));
-}
-
-TEST_F(SurfaceTextureGLTest, TexturingFromCpuFilledYV12BufferWithCrop) {
- const int texWidth = 64;
- const int texHeight = 66;
-
- ASSERT_EQ(NO_ERROR, native_window_set_buffers_geometry(mANW.get(),
- texWidth, texHeight, HAL_PIXEL_FORMAT_YV12));
- ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(),
- GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN));
-
- android_native_rect_t crops[] = {
- {4, 6, 22, 36},
- {0, 6, 22, 36},
- {4, 0, 22, 36},
- {4, 6, texWidth, 36},
- {4, 6, 22, texHeight},
- };
-
- for (int i = 0; i < 5; i++) {
- const android_native_rect_t& crop(crops[i]);
- SCOPED_TRACE(String8::format("rect{ l: %d t: %d r: %d b: %d }",
- crop.left, crop.top, crop.right, crop.bottom).string());
-
- ASSERT_EQ(NO_ERROR, native_window_set_crop(mANW.get(), &crop));
-
- ANativeWindowBuffer* anb;
- ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(),
- &anb));
- ASSERT_TRUE(anb != NULL);
-
- sp<GraphicBuffer> buf(new GraphicBuffer(anb, false));
-
- uint8_t* img = NULL;
- buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img));
- fillYV12BufferRect(img, texWidth, texHeight, buf->getStride(), crop);
- buf->unlock();
- ASSERT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(),
- buf->getNativeBuffer(), -1));
-
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
-
- glClearColor(0.2, 0.2, 0.2, 0.2);
- glClear(GL_COLOR_BUFFER_BIT);
-
- glViewport(0, 0, 64, 64);
- drawTexture();
-
- EXPECT_TRUE(checkPixel( 0, 0, 82, 255, 35, 255));
- EXPECT_TRUE(checkPixel(63, 0, 82, 255, 35, 255));
- EXPECT_TRUE(checkPixel(63, 63, 82, 255, 35, 255));
- EXPECT_TRUE(checkPixel( 0, 63, 82, 255, 35, 255));
-
- EXPECT_TRUE(checkPixel(25, 14, 82, 255, 35, 255));
- EXPECT_TRUE(checkPixel(35, 31, 82, 255, 35, 255));
- EXPECT_TRUE(checkPixel(57, 6, 82, 255, 35, 255));
- EXPECT_TRUE(checkPixel( 5, 42, 82, 255, 35, 255));
- EXPECT_TRUE(checkPixel(32, 33, 82, 255, 35, 255));
- EXPECT_TRUE(checkPixel(16, 26, 82, 255, 35, 255));
- EXPECT_TRUE(checkPixel(46, 51, 82, 255, 35, 255));
- }
-}
-
-// This test is intended to catch synchronization bugs between the CPU-written
-// and GPU-read buffers.
-TEST_F(SurfaceTextureGLTest, TexturingFromCpuFilledYV12BuffersRepeatedly) {
- enum { texWidth = 16 };
- enum { texHeight = 16 };
- enum { numFrames = 1024 };
-
- ASSERT_EQ(NO_ERROR, mST->setDefaultMaxBufferCount(2));
- ASSERT_EQ(NO_ERROR, native_window_set_buffers_geometry(mANW.get(),
- texWidth, texHeight, HAL_PIXEL_FORMAT_YV12));
- ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(),
- GRALLOC_USAGE_SW_WRITE_OFTEN));
-
- struct TestPixel {
- int x;
- int y;
- };
- const TestPixel testPixels[] = {
- { 4, 11 },
- { 12, 14 },
- { 7, 2 },
- };
- enum {numTestPixels = sizeof(testPixels) / sizeof(testPixels[0])};
-
- class ProducerThread : public Thread {
- public:
- ProducerThread(const sp<ANativeWindow>& anw,
- const TestPixel* testPixels):
- mANW(anw),
- mTestPixels(testPixels) {
- }
-
- virtual ~ProducerThread() {
- }
-
- virtual bool threadLoop() {
- for (int i = 0; i < numFrames; i++) {
- ANativeWindowBuffer* anb;
- if (native_window_dequeue_buffer_and_wait(mANW.get(),
- &anb) != NO_ERROR) {
- return false;
- }
- if (anb == NULL) {
- return false;
- }
-
- sp<GraphicBuffer> buf(new GraphicBuffer(anb, false));
-
- const int yuvTexOffsetY = 0;
- int stride = buf->getStride();
- int yuvTexStrideY = stride;
- int yuvTexOffsetV = yuvTexStrideY * texHeight;
- int yuvTexStrideV = (yuvTexStrideY/2 + 0xf) & ~0xf;
- int yuvTexOffsetU = yuvTexOffsetV + yuvTexStrideV * texHeight/2;
- int yuvTexStrideU = yuvTexStrideV;
-
- uint8_t* img = NULL;
- buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img));
-
- // Gray out all the test pixels first, so we're more likely to
- // see a failure if GL is still texturing from the buffer we
- // just dequeued.
- for (int j = 0; j < numTestPixels; j++) {
- int x = mTestPixels[j].x;
- int y = mTestPixels[j].y;
- uint8_t value = 128;
- img[y*stride + x] = value;
- }
-
- // Fill the buffer with gray.
- for (int y = 0; y < texHeight; y++) {
- for (int x = 0; x < texWidth; x++) {
- img[yuvTexOffsetY + y*yuvTexStrideY + x] = 128;
- img[yuvTexOffsetU + (y/2)*yuvTexStrideU + x/2] = 128;
- img[yuvTexOffsetV + (y/2)*yuvTexStrideV + x/2] = 128;
- }
- }
-
- // Set the test pixels to either white or black.
- for (int j = 0; j < numTestPixels; j++) {
- int x = mTestPixels[j].x;
- int y = mTestPixels[j].y;
- uint8_t value = 0;
- if (j == (i % numTestPixels)) {
- value = 255;
- }
- img[y*stride + x] = value;
- }
-
- buf->unlock();
- if (mANW->queueBuffer(mANW.get(), buf->getNativeBuffer(), -1)
- != NO_ERROR) {
- return false;
- }
- }
- return false;
- }
-
- sp<ANativeWindow> mANW;
- const TestPixel* mTestPixels;
- };
-
- sp<Thread> pt(new ProducerThread(mANW, testPixels));
- pt->run();
-
- glViewport(0, 0, texWidth, texHeight);
-
- glClearColor(0.2, 0.2, 0.2, 0.2);
- glClear(GL_COLOR_BUFFER_BIT);
-
- // We wait for the first two frames up front so that the producer will be
- // likely to dequeue the buffer that's currently being textured from.
- mFW->waitForFrame();
- mFW->waitForFrame();
-
- for (int i = 0; i < numFrames; i++) {
- SCOPED_TRACE(String8::format("frame %d", i).string());
-
- // We must wait for each frame to come in because if we ever do an
- // updateTexImage call that doesn't consume a newly available buffer
- // then the producer and consumer will get out of sync, which will cause
- // a deadlock.
- if (i > 1) {
- mFW->waitForFrame();
- }
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
- drawTexture();
-
- for (int j = 0; j < numTestPixels; j++) {
- int x = testPixels[j].x;
- int y = testPixels[j].y;
- uint8_t value = 0;
- if (j == (i % numTestPixels)) {
- // We must y-invert the texture coords
- EXPECT_TRUE(checkPixel(x, texHeight-y-1, 255, 255, 255, 255));
- } else {
- // We must y-invert the texture coords
- EXPECT_TRUE(checkPixel(x, texHeight-y-1, 0, 0, 0, 255));
- }
- }
- }
-
- pt->requestExitAndWait();
-}
-
-TEST_F(SurfaceTextureGLTest, TexturingFromCpuFilledRGBABufferNpot) {
- const int texWidth = 64;
- const int texHeight = 66;
-
- ASSERT_EQ(NO_ERROR, native_window_set_buffers_geometry(mANW.get(),
- texWidth, texHeight, HAL_PIXEL_FORMAT_RGBA_8888));
- ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(),
- GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN));
-
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
-
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
-
- glClearColor(0.2, 0.2, 0.2, 0.2);
- glClear(GL_COLOR_BUFFER_BIT);
-
- glViewport(0, 0, texWidth, texHeight);
- drawTexture();
-
- EXPECT_TRUE(checkPixel( 0, 0, 35, 35, 35, 35));
- EXPECT_TRUE(checkPixel(63, 0, 231, 231, 231, 231));
- EXPECT_TRUE(checkPixel(63, 65, 231, 231, 231, 231));
- EXPECT_TRUE(checkPixel( 0, 65, 35, 35, 35, 35));
-
- EXPECT_TRUE(checkPixel(15, 10, 35, 231, 231, 231));
- EXPECT_TRUE(checkPixel(23, 65, 231, 35, 231, 35));
- EXPECT_TRUE(checkPixel(19, 40, 35, 231, 35, 35));
- EXPECT_TRUE(checkPixel(38, 30, 231, 35, 35, 35));
- EXPECT_TRUE(checkPixel(42, 54, 35, 35, 35, 231));
- EXPECT_TRUE(checkPixel(37, 34, 35, 231, 231, 231));
- EXPECT_TRUE(checkPixel(31, 8, 231, 35, 35, 231));
- EXPECT_TRUE(checkPixel(37, 47, 231, 35, 231, 231));
- EXPECT_TRUE(checkPixel(25, 38, 35, 35, 35, 35));
- EXPECT_TRUE(checkPixel(49, 6, 35, 231, 35, 35));
- EXPECT_TRUE(checkPixel(54, 50, 35, 231, 231, 231));
- EXPECT_TRUE(checkPixel(27, 26, 231, 231, 231, 231));
- EXPECT_TRUE(checkPixel(10, 6, 35, 35, 231, 231));
- EXPECT_TRUE(checkPixel(29, 4, 35, 35, 35, 231));
- EXPECT_TRUE(checkPixel(55, 28, 35, 35, 231, 35));
- EXPECT_TRUE(checkPixel(58, 55, 35, 35, 231, 231));
-}
-
-TEST_F(SurfaceTextureGLTest, TexturingFromCpuFilledRGBABufferPow2) {
- const int texWidth = 64;
- const int texHeight = 64;
-
- ASSERT_EQ(NO_ERROR, native_window_set_buffers_geometry(mANW.get(),
- texWidth, texHeight, HAL_PIXEL_FORMAT_RGBA_8888));
- ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(),
- GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN));
-
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
-
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
-
- glClearColor(0.2, 0.2, 0.2, 0.2);
- glClear(GL_COLOR_BUFFER_BIT);
-
- glViewport(0, 0, texWidth, texHeight);
- drawTexture();
-
- EXPECT_TRUE(checkPixel( 0, 0, 231, 231, 231, 231));
- EXPECT_TRUE(checkPixel(63, 0, 35, 35, 35, 35));
- EXPECT_TRUE(checkPixel(63, 63, 231, 231, 231, 231));
- EXPECT_TRUE(checkPixel( 0, 63, 35, 35, 35, 35));
-
- EXPECT_TRUE(checkPixel(12, 46, 231, 231, 231, 35));
- EXPECT_TRUE(checkPixel(16, 1, 231, 231, 35, 231));
- EXPECT_TRUE(checkPixel(21, 12, 231, 35, 35, 231));
- EXPECT_TRUE(checkPixel(26, 51, 231, 35, 231, 35));
- EXPECT_TRUE(checkPixel( 5, 32, 35, 231, 231, 35));
- EXPECT_TRUE(checkPixel(13, 8, 35, 231, 231, 231));
- EXPECT_TRUE(checkPixel(46, 3, 35, 35, 231, 35));
- EXPECT_TRUE(checkPixel(30, 33, 35, 35, 35, 35));
- EXPECT_TRUE(checkPixel( 6, 52, 231, 231, 35, 35));
- EXPECT_TRUE(checkPixel(55, 33, 35, 231, 35, 231));
- EXPECT_TRUE(checkPixel(16, 29, 35, 35, 231, 231));
- EXPECT_TRUE(checkPixel( 1, 30, 35, 35, 35, 231));
- EXPECT_TRUE(checkPixel(41, 37, 35, 35, 231, 231));
- EXPECT_TRUE(checkPixel(46, 29, 231, 231, 35, 35));
- EXPECT_TRUE(checkPixel(15, 25, 35, 231, 35, 231));
- EXPECT_TRUE(checkPixel( 3, 52, 35, 231, 35, 35));
-}
-
-// Tests if GLConsumer and BufferQueue are robust enough
-// to handle a special case where updateTexImage is called
-// in the middle of disconnect. This ordering is enforced
-// by blocking in the disconnect callback.
-TEST_F(SurfaceTextureGLTest, DisconnectStressTest) {
-
- class ProducerThread : public Thread {
- public:
- ProducerThread(const sp<ANativeWindow>& anw):
- mANW(anw) {
- }
-
- virtual ~ProducerThread() {
- }
-
- virtual bool threadLoop() {
- ANativeWindowBuffer* anb;
-
- native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_EGL);
-
- for (int numFrames =0 ; numFrames < 2; numFrames ++) {
-
- if (native_window_dequeue_buffer_and_wait(mANW.get(),
- &anb) != NO_ERROR) {
- return false;
- }
- if (anb == NULL) {
- return false;
- }
- if (mANW->queueBuffer(mANW.get(), anb, -1)
- != NO_ERROR) {
- return false;
- }
- }
-
- native_window_api_disconnect(mANW.get(), NATIVE_WINDOW_API_EGL);
-
- return false;
- }
-
- private:
- sp<ANativeWindow> mANW;
- };
-
- sp<DisconnectWaiter> dw(new DisconnectWaiter());
- mBQ->consumerConnect(dw, false);
-
-
- sp<Thread> pt(new ProducerThread(mANW));
- pt->run();
-
- // eat a frame so GLConsumer will own an at least one slot
- dw->waitForFrame();
- EXPECT_EQ(OK,mST->updateTexImage());
-
- dw->waitForFrame();
- // Could fail here as GLConsumer thinks it still owns the slot
- // but bufferQueue has released all slots
- EXPECT_EQ(OK,mST->updateTexImage());
-
- dw->finishDisconnect();
-}
-
-
-// This test ensures that the GLConsumer clears the mCurrentTexture
-// when it is disconnected and reconnected. Otherwise it will
-// attempt to release a buffer that it does not owned
-TEST_F(SurfaceTextureGLTest, DisconnectClearsCurrentTexture) {
- ASSERT_EQ(OK, native_window_api_connect(mANW.get(),
- NATIVE_WINDOW_API_EGL));
-
- ANativeWindowBuffer *anb;
-
- EXPECT_EQ (OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb));
- EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1));
-
- EXPECT_EQ (OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb));
- EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1));
-
- EXPECT_EQ(OK,mST->updateTexImage());
- EXPECT_EQ(OK,mST->updateTexImage());
-
- ASSERT_EQ(OK, native_window_api_disconnect(mANW.get(),
- NATIVE_WINDOW_API_EGL));
- ASSERT_EQ(OK, native_window_api_connect(mANW.get(),
- NATIVE_WINDOW_API_EGL));
-
- EXPECT_EQ(OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb));
- EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1));
-
- // Will fail here if mCurrentTexture is not cleared properly
- mFW->waitForFrame();
- EXPECT_EQ(OK,mST->updateTexImage());
-
- ASSERT_EQ(OK, native_window_api_disconnect(mANW.get(),
- NATIVE_WINDOW_API_EGL));
-}
-
-TEST_F(SurfaceTextureGLTest, ScaleToWindowMode) {
- ASSERT_EQ(OK, native_window_set_scaling_mode(mANW.get(),
- NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW));
-
- // The producer image size
- ASSERT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 512, 512));
-
- // The consumer image size (16 x 9) ratio
- mST->setDefaultBufferSize(1280, 720);
-
- ASSERT_EQ(OK, native_window_api_connect(mANW.get(),
- NATIVE_WINDOW_API_CPU));
-
- ANativeWindowBuffer *anb;
-
- android_native_rect_t odd = {23, 78, 123, 477};
- ASSERT_EQ(OK, native_window_set_crop(mANW.get(), &odd));
- EXPECT_EQ (OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb));
- EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1));
- mFW->waitForFrame();
- EXPECT_EQ(OK, mST->updateTexImage());
- Rect r = mST->getCurrentCrop();
- assertRectEq(Rect(23, 78, 123, 477), r);
-
- ASSERT_EQ(OK, native_window_api_disconnect(mANW.get(),
- NATIVE_WINDOW_API_CPU));
-}
-
-// This test ensures the scaling mode does the right thing
-// ie NATIVE_WINDOW_SCALING_MODE_CROP should crop
-// the image such that it has the same aspect ratio as the
-// default buffer size
-TEST_F(SurfaceTextureGLTest, CroppedScalingMode) {
- ASSERT_EQ(OK, native_window_set_scaling_mode(mANW.get(),
- NATIVE_WINDOW_SCALING_MODE_SCALE_CROP));
-
- // The producer image size
- ASSERT_EQ(OK, native_window_set_buffers_dimensions(mANW.get(), 512, 512));
-
- // The consumer image size (16 x 9) ratio
- mST->setDefaultBufferSize(1280, 720);
-
- native_window_api_connect(mANW.get(), NATIVE_WINDOW_API_CPU);
-
- ANativeWindowBuffer *anb;
-
- // The crop is in the shape of (320, 180) === 16 x 9
- android_native_rect_t standard = {10, 20, 330, 200};
- ASSERT_EQ(OK, native_window_set_crop(mANW.get(), &standard));
- EXPECT_EQ (OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb));
- EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1));
- mFW->waitForFrame();
- EXPECT_EQ(OK, mST->updateTexImage());
- Rect r = mST->getCurrentCrop();
- // crop should be the same as crop (same aspect ratio)
- assertRectEq(Rect(10, 20, 330, 200), r);
-
- // make this wider then desired aspect 239 x 100 (2.39:1)
- android_native_rect_t wide = {20, 30, 259, 130};
- ASSERT_EQ(OK, native_window_set_crop(mANW.get(), &wide));
- EXPECT_EQ (OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb));
- EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1));
- mFW->waitForFrame();
- EXPECT_EQ(OK, mST->updateTexImage());
- r = mST->getCurrentCrop();
- // crop should be the same height, but have cropped left and right borders
- // offset is 30.6 px L+, R-
- assertRectEq(Rect(51, 30, 228, 130), r);
-
- // This image is taller then desired aspect 400 x 300 (4:3)
- android_native_rect_t narrow = {0, 0, 400, 300};
- ASSERT_EQ(OK, native_window_set_crop(mANW.get(), &narrow));
- EXPECT_EQ (OK, native_window_dequeue_buffer_and_wait(mANW.get(), &anb));
- EXPECT_EQ(OK, mANW->queueBuffer(mANW.get(), anb, -1));
- mFW->waitForFrame();
- EXPECT_EQ(OK, mST->updateTexImage());
- r = mST->getCurrentCrop();
- // crop should be the same width, but have cropped top and bottom borders
- // offset is 37.5 px
- assertRectEq(Rect(0, 37, 400, 262), r);
-
- native_window_api_disconnect(mANW.get(), NATIVE_WINDOW_API_CPU);
-}
-
-TEST_F(SurfaceTextureGLTest, AbandonUnblocksDequeueBuffer) {
- class ProducerThread : public Thread {
- public:
- ProducerThread(const sp<ANativeWindow>& anw):
- mANW(anw),
- mDequeueError(NO_ERROR) {
- }
-
- virtual ~ProducerThread() {
- }
-
- virtual bool threadLoop() {
- Mutex::Autolock lock(mMutex);
- ANativeWindowBuffer* anb;
-
- // Frame 1
- if (native_window_dequeue_buffer_and_wait(mANW.get(),
- &anb) != NO_ERROR) {
- return false;
- }
- if (anb == NULL) {
- return false;
- }
- if (mANW->queueBuffer(mANW.get(), anb, -1)
- != NO_ERROR) {
- return false;
- }
-
- // Frame 2
- if (native_window_dequeue_buffer_and_wait(mANW.get(),
- &anb) != NO_ERROR) {
- return false;
- }
- if (anb == NULL) {
- return false;
- }
- if (mANW->queueBuffer(mANW.get(), anb, -1)
- != NO_ERROR) {
- return false;
- }
-
- // Frame 3 - error expected
- mDequeueError = native_window_dequeue_buffer_and_wait(mANW.get(),
- &anb);
- return false;
- }
-
- status_t getDequeueError() {
- Mutex::Autolock lock(mMutex);
- return mDequeueError;
- }
-
- private:
- sp<ANativeWindow> mANW;
- status_t mDequeueError;
- Mutex mMutex;
- };
-
- ASSERT_EQ(OK, mST->setDefaultMaxBufferCount(2));
-
- sp<Thread> pt(new ProducerThread(mANW));
- pt->run();
-
- mFW->waitForFrame();
- mFW->waitForFrame();
-
- // Sleep for 100ms to allow the producer thread's dequeueBuffer call to
- // block waiting for a buffer to become available.
- usleep(100000);
-
- mST->abandon();
-
- pt->requestExitAndWait();
- ASSERT_EQ(NO_INIT,
- reinterpret_cast<ProducerThread*>(pt.get())->getDequeueError());
-}
-
-TEST_F(SurfaceTextureGLTest, InvalidWidthOrHeightFails) {
- int texHeight = 16;
- ANativeWindowBuffer* anb;
-
- GLint maxTextureSize;
- glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
-
- // make sure it works with small textures
- mST->setDefaultBufferSize(16, texHeight);
- EXPECT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(),
- &anb));
- EXPECT_EQ(16, anb->width);
- EXPECT_EQ(texHeight, anb->height);
- EXPECT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), anb, -1));
- EXPECT_EQ(NO_ERROR, mST->updateTexImage());
-
- // make sure it works with GL_MAX_TEXTURE_SIZE
- mST->setDefaultBufferSize(maxTextureSize, texHeight);
- EXPECT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(),
- &anb));
- EXPECT_EQ(maxTextureSize, anb->width);
- EXPECT_EQ(texHeight, anb->height);
- EXPECT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), anb, -1));
- EXPECT_EQ(NO_ERROR, mST->updateTexImage());
-
- // make sure it fails with GL_MAX_TEXTURE_SIZE+1
- mST->setDefaultBufferSize(maxTextureSize+1, texHeight);
- EXPECT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(),
- &anb));
- EXPECT_EQ(maxTextureSize+1, anb->width);
- EXPECT_EQ(texHeight, anb->height);
- EXPECT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), anb, -1));
- ASSERT_NE(NO_ERROR, mST->updateTexImage());
-}
-
-/*
- * This test fixture is for testing GL -> GL texture streaming. It creates an
- * EGLSurface and an EGLContext for the image producer to use.
- */
-class SurfaceTextureGLToGLTest : public SurfaceTextureGLTest {
-protected:
- SurfaceTextureGLToGLTest():
- mProducerEglSurface(EGL_NO_SURFACE),
- mProducerEglContext(EGL_NO_CONTEXT) {
- }
-
- virtual void SetUp() {
- SurfaceTextureGLTest::SetUp();
-
- mProducerEglSurface = eglCreateWindowSurface(mEglDisplay, mGlConfig,
- mANW.get(), NULL);
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
- ASSERT_NE(EGL_NO_SURFACE, mProducerEglSurface);
-
- mProducerEglContext = eglCreateContext(mEglDisplay, mGlConfig,
- EGL_NO_CONTEXT, getContextAttribs());
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
- ASSERT_NE(EGL_NO_CONTEXT, mProducerEglContext);
- }
-
- virtual void TearDown() {
- if (mProducerEglContext != EGL_NO_CONTEXT) {
- eglDestroyContext(mEglDisplay, mProducerEglContext);
- }
- if (mProducerEglSurface != EGL_NO_SURFACE) {
- eglDestroySurface(mEglDisplay, mProducerEglSurface);
- }
- SurfaceTextureGLTest::TearDown();
- }
-
- EGLSurface mProducerEglSurface;
- EGLContext mProducerEglContext;
-};
-
-TEST_F(SurfaceTextureGLToGLTest, TransformHintGetsRespected) {
- const uint32_t texWidth = 32;
- const uint32_t texHeight = 64;
-
- mST->setDefaultBufferSize(texWidth, texHeight);
- mST->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_90);
-
- // This test requires 3 buffers to avoid deadlock because we're
- // both producer and consumer, and only using one thread.
- mST->setDefaultMaxBufferCount(3);
-
- // Do the producer side of things
- EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
- mProducerEglSurface, mProducerEglContext));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
-
- // Start a buffer with our chosen size and transform hint moving
- // through the system.
- glClear(GL_COLOR_BUFFER_BIT); // give the driver something to do
- eglSwapBuffers(mEglDisplay, mProducerEglSurface);
- mST->updateTexImage(); // consume it
- // Swap again.
- glClear(GL_COLOR_BUFFER_BIT);
- eglSwapBuffers(mEglDisplay, mProducerEglSurface);
- mST->updateTexImage();
-
- // The current buffer should either show the effects of the transform
- // hint (in the form of an inverse transform), or show that the
- // transform hint has been ignored.
- sp<GraphicBuffer> buf = mST->getCurrentBuffer();
- if (mST->getCurrentTransform() == NATIVE_WINDOW_TRANSFORM_ROT_270) {
- ASSERT_EQ(texWidth, buf->getHeight());
- ASSERT_EQ(texHeight, buf->getWidth());
- } else {
- ASSERT_EQ(texWidth, buf->getWidth());
- ASSERT_EQ(texHeight, buf->getHeight());
- }
-
- // Reset the transform hint and confirm that it takes.
- mST->setTransformHint(0);
- glClear(GL_COLOR_BUFFER_BIT);
- eglSwapBuffers(mEglDisplay, mProducerEglSurface);
- mST->updateTexImage();
- glClear(GL_COLOR_BUFFER_BIT);
- eglSwapBuffers(mEglDisplay, mProducerEglSurface);
- mST->updateTexImage();
-
- buf = mST->getCurrentBuffer();
- ASSERT_EQ((uint32_t) 0, mST->getCurrentTransform());
- ASSERT_EQ(texWidth, buf->getWidth());
- ASSERT_EQ(texHeight, buf->getHeight());
-}
-
-TEST_F(SurfaceTextureGLToGLTest, TexturingFromGLFilledRGBABufferPow2) {
- const int texWidth = 64;
- const int texHeight = 64;
-
- mST->setDefaultBufferSize(texWidth, texHeight);
-
- // This test requires 3 buffers to complete run on a single thread.
- mST->setDefaultMaxBufferCount(3);
-
- // Do the producer side of things
- EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
- mProducerEglSurface, mProducerEglContext));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
-
- // This is needed to ensure we pick up a buffer of the correct size.
- eglSwapBuffers(mEglDisplay, mProducerEglSurface);
-
- glClearColor(0.6, 0.6, 0.6, 0.6);
- glClear(GL_COLOR_BUFFER_BIT);
-
- glEnable(GL_SCISSOR_TEST);
- glScissor(4, 4, 4, 4);
- glClearColor(1.0, 0.0, 0.0, 1.0);
- glClear(GL_COLOR_BUFFER_BIT);
-
- glScissor(24, 48, 4, 4);
- glClearColor(0.0, 1.0, 0.0, 1.0);
- glClear(GL_COLOR_BUFFER_BIT);
-
- glScissor(37, 17, 4, 4);
- glClearColor(0.0, 0.0, 1.0, 1.0);
- glClear(GL_COLOR_BUFFER_BIT);
-
- eglSwapBuffers(mEglDisplay, mProducerEglSurface);
-
- // Do the consumer side of things
- EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
- mEglContext));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
-
- glDisable(GL_SCISSOR_TEST);
-
- // Skip the first frame, which was empty
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
-
- glClearColor(0.2, 0.2, 0.2, 0.2);
- glClear(GL_COLOR_BUFFER_BIT);
-
- glViewport(0, 0, texWidth, texHeight);
- drawTexture();
-
- EXPECT_TRUE(checkPixel( 0, 0, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(63, 0, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(63, 63, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel( 0, 63, 153, 153, 153, 153));
-
- EXPECT_TRUE(checkPixel( 4, 7, 255, 0, 0, 255));
- EXPECT_TRUE(checkPixel(25, 51, 0, 255, 0, 255));
- EXPECT_TRUE(checkPixel(40, 19, 0, 0, 255, 255));
- EXPECT_TRUE(checkPixel(29, 51, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel( 5, 32, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(13, 8, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(46, 3, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(30, 33, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel( 6, 52, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(55, 33, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(16, 29, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel( 1, 30, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(41, 37, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(46, 29, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(15, 25, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel( 3, 52, 153, 153, 153, 153));
-}
-
-TEST_F(SurfaceTextureGLToGLTest, EglDestroySurfaceUnrefsBuffers) {
- sp<GraphicBuffer> buffers[2];
-
- // This test requires async mode to run on a single thread.
- EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
- mProducerEglSurface, mProducerEglContext));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
- EXPECT_TRUE(eglSwapInterval(mEglDisplay, 0));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
-
- for (int i = 0; i < 2; i++) {
- // Produce a frame
- EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
- mProducerEglSurface, mProducerEglContext));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
- glClear(GL_COLOR_BUFFER_BIT);
- eglSwapBuffers(mEglDisplay, mProducerEglSurface);
-
- // Consume a frame
- EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
- mEglContext));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
- mFW->waitForFrame();
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
- buffers[i] = mST->getCurrentBuffer();
- }
-
- // Destroy the GL texture object to release its ref on buffers[2].
- GLuint texID = TEX_ID;
- glDeleteTextures(1, &texID);
-
- // Destroy the EGLSurface
- EXPECT_TRUE(eglDestroySurface(mEglDisplay, mProducerEglSurface));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
- mProducerEglSurface = EGL_NO_SURFACE;
-
- // This test should have the only reference to buffer 0.
- EXPECT_EQ(1, buffers[0]->getStrongCount());
-
- // The GLConsumer should hold a single reference to buffer 1 in its
- // mCurrentBuffer member. All of the references in the slots should have
- // been released.
- EXPECT_EQ(2, buffers[1]->getStrongCount());
-}
-
-TEST_F(SurfaceTextureGLToGLTest, EglDestroySurfaceAfterAbandonUnrefsBuffers) {
- sp<GraphicBuffer> buffers[3];
-
- // This test requires async mode to run on a single thread.
- EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
- mProducerEglSurface, mProducerEglContext));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
- EXPECT_TRUE(eglSwapInterval(mEglDisplay, 0));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
-
- for (int i = 0; i < 3; i++) {
- // Produce a frame
- EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
- mProducerEglSurface, mProducerEglContext));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
- glClear(GL_COLOR_BUFFER_BIT);
- EXPECT_TRUE(eglSwapBuffers(mEglDisplay, mProducerEglSurface));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
-
- // Consume a frame
- EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
- mEglContext));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
- mFW->waitForFrame();
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
- buffers[i] = mST->getCurrentBuffer();
- }
-
- // Abandon the GLConsumer, releasing the ref that the GLConsumer has
- // on buffers[2].
- mST->abandon();
-
- // Destroy the GL texture object to release its ref on buffers[2].
- GLuint texID = TEX_ID;
- glDeleteTextures(1, &texID);
-
- // Destroy the EGLSurface.
- EXPECT_TRUE(eglDestroySurface(mEglDisplay, mProducerEglSurface));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
- mProducerEglSurface = EGL_NO_SURFACE;
-
- EXPECT_EQ(1, buffers[0]->getStrongCount());
- EXPECT_EQ(1, buffers[1]->getStrongCount());
-
- // Depending on how lazily the GL driver dequeues buffers, we may end up
- // with either two or three total buffers. If there are three, make sure
- // the last one was properly down-ref'd.
- if (buffers[2] != buffers[0]) {
- EXPECT_EQ(1, buffers[2]->getStrongCount());
- }
-}
-
-TEST_F(SurfaceTextureGLToGLTest, EglMakeCurrentBeforeConsumerDeathUnrefsBuffers) {
- sp<GraphicBuffer> buffer;
-
- EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
- mProducerEglSurface, mProducerEglContext));
-
- // Produce a frame
- glClear(GL_COLOR_BUFFER_BIT);
- EXPECT_TRUE(eglSwapBuffers(mEglDisplay, mProducerEglSurface));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
-
- // Destroy the EGLSurface.
- EXPECT_TRUE(eglDestroySurface(mEglDisplay, mProducerEglSurface));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
- mProducerEglSurface = EGL_NO_SURFACE;
- mSTC.clear();
- mANW.clear();
- mTextureRenderer.clear();
-
- // Consume a frame
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
- buffer = mST->getCurrentBuffer();
-
- // Destroy the GL texture object to release its ref
- GLuint texID = TEX_ID;
- glDeleteTextures(1, &texID);
-
- // make un-current, all references to buffer should be gone
- EXPECT_TRUE(eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE,
- EGL_NO_SURFACE, EGL_NO_CONTEXT));
-
- // Destroy consumer
- mST.clear();
-
- EXPECT_EQ(1, buffer->getStrongCount());
-}
-
-TEST_F(SurfaceTextureGLToGLTest, EglMakeCurrentAfterConsumerDeathUnrefsBuffers) {
- sp<GraphicBuffer> buffer;
-
- EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
- mProducerEglSurface, mProducerEglContext));
-
- // Produce a frame
- glClear(GL_COLOR_BUFFER_BIT);
- EXPECT_TRUE(eglSwapBuffers(mEglDisplay, mProducerEglSurface));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
-
- // Destroy the EGLSurface.
- EXPECT_TRUE(eglDestroySurface(mEglDisplay, mProducerEglSurface));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
- mProducerEglSurface = EGL_NO_SURFACE;
- mSTC.clear();
- mANW.clear();
- mTextureRenderer.clear();
-
- // Consume a frame
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
- buffer = mST->getCurrentBuffer();
-
- // Destroy the GL texture object to release its ref
- GLuint texID = TEX_ID;
- glDeleteTextures(1, &texID);
-
- // Destroy consumer
- mST.clear();
-
- // make un-current, all references to buffer should be gone
- EXPECT_TRUE(eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE,
- EGL_NO_SURFACE, EGL_NO_CONTEXT));
-
- EXPECT_EQ(1, buffer->getStrongCount());
-}
-
-TEST_F(SurfaceTextureGLToGLTest, TexturingFromUserSizedGLFilledBuffer) {
- enum { texWidth = 64 };
- enum { texHeight = 64 };
-
- // This test requires 3 buffers to complete run on a single thread.
- mST->setDefaultMaxBufferCount(3);
-
- // Set the user buffer size.
- native_window_set_buffers_user_dimensions(mANW.get(), texWidth, texHeight);
-
- // Do the producer side of things
- EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
- mProducerEglSurface, mProducerEglContext));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
-
- // This is needed to ensure we pick up a buffer of the correct size.
- eglSwapBuffers(mEglDisplay, mProducerEglSurface);
-
- glClearColor(0.6, 0.6, 0.6, 0.6);
- glClear(GL_COLOR_BUFFER_BIT);
-
- glEnable(GL_SCISSOR_TEST);
- glScissor(4, 4, 1, 1);
- glClearColor(1.0, 0.0, 0.0, 1.0);
- glClear(GL_COLOR_BUFFER_BIT);
-
- eglSwapBuffers(mEglDisplay, mProducerEglSurface);
-
- // Do the consumer side of things
- EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
- mEglContext));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
-
- glDisable(GL_SCISSOR_TEST);
-
- // Skip the first frame, which was empty
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
-
- glClearColor(0.2, 0.2, 0.2, 0.2);
- glClear(GL_COLOR_BUFFER_BIT);
-
- glViewport(0, 0, texWidth, texHeight);
- drawTexture();
-
- EXPECT_TRUE(checkPixel( 0, 0, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(63, 0, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(63, 63, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel( 0, 63, 153, 153, 153, 153));
-
- EXPECT_TRUE(checkPixel( 4, 4, 255, 0, 0, 255));
- EXPECT_TRUE(checkPixel( 5, 5, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel( 3, 3, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(45, 52, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(12, 36, 153, 153, 153, 153));
-}
-
-TEST_F(SurfaceTextureGLToGLTest, TexturingFromPreRotatedUserSizedGLFilledBuffer) {
- enum { texWidth = 64 };
- enum { texHeight = 16 };
-
- // This test requires 3 buffers to complete run on a single thread.
- mST->setDefaultMaxBufferCount(3);
-
- // Set the transform hint.
- mST->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_90);
-
- // Set the user buffer size.
- native_window_set_buffers_user_dimensions(mANW.get(), texWidth, texHeight);
-
- // Do the producer side of things
- EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
- mProducerEglSurface, mProducerEglContext));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
-
- // This is needed to ensure we pick up a buffer of the correct size and the
- // new rotation hint.
- eglSwapBuffers(mEglDisplay, mProducerEglSurface);
-
- glClearColor(0.6, 0.6, 0.6, 0.6);
- glClear(GL_COLOR_BUFFER_BIT);
-
- glEnable(GL_SCISSOR_TEST);
- glScissor(24, 4, 1, 1);
- glClearColor(1.0, 0.0, 0.0, 1.0);
- glClear(GL_COLOR_BUFFER_BIT);
-
- eglSwapBuffers(mEglDisplay, mProducerEglSurface);
-
- // Do the consumer side of things
- EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
- mEglContext));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
-
- glDisable(GL_SCISSOR_TEST);
-
- // Skip the first frame, which was empty
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
-
- glClearColor(0.2, 0.2, 0.2, 0.2);
- glClear(GL_COLOR_BUFFER_BIT);
-
- glViewport(0, 0, texWidth, texHeight);
- drawTexture();
-
- EXPECT_TRUE(checkPixel( 0, 0, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(63, 0, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(63, 15, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel( 0, 15, 153, 153, 153, 153));
-
- EXPECT_TRUE(checkPixel(24, 4, 255, 0, 0, 255));
- EXPECT_TRUE(checkPixel(25, 5, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(23, 3, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(45, 13, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(12, 8, 153, 153, 153, 153));
-}
-
-TEST_F(SurfaceTextureGLToGLTest, TexturingFromPreRotatedGLFilledBuffer) {
- enum { texWidth = 64 };
- enum { texHeight = 16 };
-
- // This test requires 3 buffers to complete run on a single thread.
- mST->setDefaultMaxBufferCount(3);
-
- // Set the transform hint.
- mST->setTransformHint(NATIVE_WINDOW_TRANSFORM_ROT_90);
-
- // Set the default buffer size.
- mST->setDefaultBufferSize(texWidth, texHeight);
-
- // Do the producer side of things
- EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mProducerEglSurface,
- mProducerEglSurface, mProducerEglContext));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
-
- // This is needed to ensure we pick up a buffer of the correct size and the
- // new rotation hint.
- eglSwapBuffers(mEglDisplay, mProducerEglSurface);
-
- glClearColor(0.6, 0.6, 0.6, 0.6);
- glClear(GL_COLOR_BUFFER_BIT);
-
- glEnable(GL_SCISSOR_TEST);
- glScissor(24, 4, 1, 1);
- glClearColor(1.0, 0.0, 0.0, 1.0);
- glClear(GL_COLOR_BUFFER_BIT);
-
- eglSwapBuffers(mEglDisplay, mProducerEglSurface);
-
- // Do the consumer side of things
- EXPECT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
- mEglContext));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
-
- glDisable(GL_SCISSOR_TEST);
-
- // Skip the first frame, which was empty
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
-
- glClearColor(0.2, 0.2, 0.2, 0.2);
- glClear(GL_COLOR_BUFFER_BIT);
-
- glViewport(0, 0, texWidth, texHeight);
- drawTexture();
-
- EXPECT_TRUE(checkPixel( 0, 0, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(63, 0, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(63, 15, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel( 0, 15, 153, 153, 153, 153));
-
- EXPECT_TRUE(checkPixel(24, 4, 255, 0, 0, 255));
- EXPECT_TRUE(checkPixel(25, 5, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(23, 3, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(45, 13, 153, 153, 153, 153));
- EXPECT_TRUE(checkPixel(12, 8, 153, 153, 153, 153));
-}
-
-/*
- * This test fixture is for testing GL -> GL texture streaming from one thread
- * to another. It contains functionality to create a producer thread that will
- * perform GL rendering to an ANativeWindow that feeds frames to a
- * GLConsumer. Additionally it supports interlocking the producer and
- * consumer threads so that a specific sequence of calls can be
- * deterministically created by the test.
- *
- * The intended usage is as follows:
- *
- * TEST_F(...) {
- * class PT : public ProducerThread {
- * virtual void render() {
- * ...
- * swapBuffers();
- * }
- * };
- *
- * runProducerThread(new PT());
- *
- * // The order of these calls will vary from test to test and may include
- * // multiple frames and additional operations (e.g. GL rendering from the
- * // texture).
- * fc->waitForFrame();
- * mST->updateTexImage();
- * fc->finishFrame();
- * }
- *
- */
-class SurfaceTextureGLThreadToGLTest : public SurfaceTextureGLToGLTest {
-protected:
-
- // ProducerThread is an abstract base class to simplify the creation of
- // OpenGL ES frame producer threads.
- class ProducerThread : public Thread {
- public:
- virtual ~ProducerThread() {
- }
-
- void setEglObjects(EGLDisplay producerEglDisplay,
- EGLSurface producerEglSurface,
- EGLContext producerEglContext) {
- mProducerEglDisplay = producerEglDisplay;
- mProducerEglSurface = producerEglSurface;
- mProducerEglContext = producerEglContext;
- }
-
- virtual bool threadLoop() {
- eglMakeCurrent(mProducerEglDisplay, mProducerEglSurface,
- mProducerEglSurface, mProducerEglContext);
- render();
- eglMakeCurrent(mProducerEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
- EGL_NO_CONTEXT);
- return false;
- }
-
- protected:
- virtual void render() = 0;
-
- void swapBuffers() {
- eglSwapBuffers(mProducerEglDisplay, mProducerEglSurface);
- }
-
- EGLDisplay mProducerEglDisplay;
- EGLSurface mProducerEglSurface;
- EGLContext mProducerEglContext;
- };
-
- // FrameCondition is a utility class for interlocking between the producer
- // and consumer threads. The FrameCondition object should be created and
- // destroyed in the consumer thread only. The consumer thread should set
- // the FrameCondition as the FrameAvailableListener of the GLConsumer,
- // and should call both waitForFrame and finishFrame once for each expected
- // frame.
- //
- // This interlocking relies on the fact that onFrameAvailable gets called
- // synchronously from GLConsumer::queueBuffer.
- class FrameCondition : public GLConsumer::FrameAvailableListener {
- public:
- FrameCondition():
- mFrameAvailable(false),
- mFrameFinished(false) {
- }
-
- // waitForFrame waits for the next frame to arrive. This should be
- // called from the consumer thread once for every frame expected by the
- // test.
- void waitForFrame() {
- Mutex::Autolock lock(mMutex);
- ALOGV("+waitForFrame");
- while (!mFrameAvailable) {
- mFrameAvailableCondition.wait(mMutex);
- }
- mFrameAvailable = false;
- ALOGV("-waitForFrame");
- }
-
- // Allow the producer to return from its swapBuffers call and continue
- // on to produce the next frame. This should be called by the consumer
- // thread once for every frame expected by the test.
- void finishFrame() {
- Mutex::Autolock lock(mMutex);
- ALOGV("+finishFrame");
- mFrameFinished = true;
- mFrameFinishCondition.signal();
- ALOGV("-finishFrame");
- }
-
- // This should be called by GLConsumer on the producer thread.
- virtual void onFrameAvailable() {
- Mutex::Autolock lock(mMutex);
- ALOGV("+onFrameAvailable");
- mFrameAvailable = true;
- mFrameAvailableCondition.signal();
- while (!mFrameFinished) {
- mFrameFinishCondition.wait(mMutex);
- }
- mFrameFinished = false;
- ALOGV("-onFrameAvailable");
- }
-
- protected:
- bool mFrameAvailable;
- bool mFrameFinished;
-
- Mutex mMutex;
- Condition mFrameAvailableCondition;
- Condition mFrameFinishCondition;
- };
-
- virtual void SetUp() {
- SurfaceTextureGLToGLTest::SetUp();
- mFC = new FrameCondition();
- mST->setFrameAvailableListener(mFC);
- }
-
- virtual void TearDown() {
- if (mProducerThread != NULL) {
- mProducerThread->requestExitAndWait();
- }
- mProducerThread.clear();
- mFC.clear();
- SurfaceTextureGLToGLTest::TearDown();
- }
-
- void runProducerThread(const sp<ProducerThread> producerThread) {
- ASSERT_TRUE(mProducerThread == NULL);
- mProducerThread = producerThread;
- producerThread->setEglObjects(mEglDisplay, mProducerEglSurface,
- mProducerEglContext);
- producerThread->run();
- }
-
- sp<ProducerThread> mProducerThread;
- sp<FrameCondition> mFC;
-};
-
-TEST_F(SurfaceTextureGLThreadToGLTest,
- UpdateTexImageBeforeFrameFinishedCompletes) {
- class PT : public ProducerThread {
- virtual void render() {
- glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
- glClear(GL_COLOR_BUFFER_BIT);
- swapBuffers();
- }
- };
-
- runProducerThread(new PT());
-
- mFC->waitForFrame();
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
- mFC->finishFrame();
-
- // TODO: Add frame verification once RGB TEX_EXTERNAL_OES is supported!
-}
-
-TEST_F(SurfaceTextureGLThreadToGLTest,
- UpdateTexImageAfterFrameFinishedCompletes) {
- class PT : public ProducerThread {
- virtual void render() {
- glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
- glClear(GL_COLOR_BUFFER_BIT);
- swapBuffers();
- }
- };
-
- runProducerThread(new PT());
-
- mFC->waitForFrame();
- mFC->finishFrame();
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
-
- // TODO: Add frame verification once RGB TEX_EXTERNAL_OES is supported!
-}
-
-TEST_F(SurfaceTextureGLThreadToGLTest,
- RepeatedUpdateTexImageBeforeFrameFinishedCompletes) {
- enum { NUM_ITERATIONS = 1024 };
-
- class PT : public ProducerThread {
- virtual void render() {
- for (int i = 0; i < NUM_ITERATIONS; i++) {
- glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
- glClear(GL_COLOR_BUFFER_BIT);
- ALOGV("+swapBuffers");
- swapBuffers();
- ALOGV("-swapBuffers");
- }
- }
- };
-
- runProducerThread(new PT());
-
- for (int i = 0; i < NUM_ITERATIONS; i++) {
- mFC->waitForFrame();
- ALOGV("+updateTexImage");
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
- ALOGV("-updateTexImage");
- mFC->finishFrame();
-
- // TODO: Add frame verification once RGB TEX_EXTERNAL_OES is supported!
- }
-}
-
-TEST_F(SurfaceTextureGLThreadToGLTest,
- RepeatedUpdateTexImageAfterFrameFinishedCompletes) {
- enum { NUM_ITERATIONS = 1024 };
-
- class PT : public ProducerThread {
- virtual void render() {
- for (int i = 0; i < NUM_ITERATIONS; i++) {
- glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
- glClear(GL_COLOR_BUFFER_BIT);
- ALOGV("+swapBuffers");
- swapBuffers();
- ALOGV("-swapBuffers");
- }
- }
- };
-
- runProducerThread(new PT());
-
- for (int i = 0; i < NUM_ITERATIONS; i++) {
- mFC->waitForFrame();
- mFC->finishFrame();
- ALOGV("+updateTexImage");
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
- ALOGV("-updateTexImage");
-
- // TODO: Add frame verification once RGB TEX_EXTERNAL_OES is supported!
- }
-}
-
-// XXX: This test is disabled because it is currently hanging on some devices.
-TEST_F(SurfaceTextureGLThreadToGLTest,
- DISABLED_RepeatedSwapBuffersWhileDequeueStalledCompletes) {
- enum { NUM_ITERATIONS = 64 };
-
- class PT : public ProducerThread {
- virtual void render() {
- for (int i = 0; i < NUM_ITERATIONS; i++) {
- glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
- glClear(GL_COLOR_BUFFER_BIT);
- ALOGV("+swapBuffers");
- swapBuffers();
- ALOGV("-swapBuffers");
- }
- }
- };
-
- ASSERT_EQ(OK, mST->setDefaultMaxBufferCount(2));
-
- runProducerThread(new PT());
-
- // Allow three frames to be rendered and queued before starting the
- // rendering in this thread. For the latter two frames we don't call
- // updateTexImage so the next dequeue from the producer thread will block
- // waiting for a frame to become available.
- mFC->waitForFrame();
- mFC->finishFrame();
-
- // We must call updateTexImage to consume the first frame so that the
- // SurfaceTexture is able to reduce the buffer count to 2. This is because
- // the GL driver may dequeue a buffer when the EGLSurface is created, and
- // that happens before we call setDefaultMaxBufferCount. It's possible that the
- // driver does not dequeue a buffer at EGLSurface creation time, so we
- // cannot rely on this to cause the second dequeueBuffer call to block.
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
-
- mFC->waitForFrame();
- mFC->finishFrame();
- mFC->waitForFrame();
- mFC->finishFrame();
-
- // Sleep for 100ms to allow the producer thread's dequeueBuffer call to
- // block waiting for a buffer to become available.
- usleep(100000);
-
- // Render and present a number of images. This thread should not be blocked
- // by the fact that the producer thread is blocking in dequeue.
- for (int i = 0; i < NUM_ITERATIONS; i++) {
- glClear(GL_COLOR_BUFFER_BIT);
- eglSwapBuffers(mEglDisplay, mEglSurface);
- }
-
- // Consume the two pending buffers to unblock the producer thread.
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
-
- // Consume the remaining buffers from the producer thread.
- for (int i = 0; i < NUM_ITERATIONS-3; i++) {
- mFC->waitForFrame();
- mFC->finishFrame();
- ALOGV("+updateTexImage");
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
- ALOGV("-updateTexImage");
- }
-}
-
-class SurfaceTextureFBOTest : public SurfaceTextureGLTest {
-protected:
-
- virtual void SetUp() {
- SurfaceTextureGLTest::SetUp();
-
- glGenFramebuffers(1, &mFbo);
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
-
- glGenTextures(1, &mFboTex);
- glBindTexture(GL_TEXTURE_2D, mFboTex);
- glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, getSurfaceWidth(),
- getSurfaceHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
- glBindTexture(GL_TEXTURE_2D, 0);
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
-
- glBindFramebuffer(GL_FRAMEBUFFER, mFbo);
- glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
- GL_TEXTURE_2D, mFboTex, 0);
- glBindFramebuffer(GL_FRAMEBUFFER, 0);
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
- }
-
- virtual void TearDown() {
- SurfaceTextureGLTest::TearDown();
-
- glDeleteTextures(1, &mFboTex);
- glDeleteFramebuffers(1, &mFbo);
- }
-
- GLuint mFbo;
- GLuint mFboTex;
-};
-
-// This test is intended to verify that proper synchronization is done when
-// rendering into an FBO.
-TEST_F(SurfaceTextureFBOTest, BlitFromCpuFilledBufferToFbo) {
- const int texWidth = 64;
- const int texHeight = 64;
-
- ASSERT_EQ(NO_ERROR, native_window_set_buffers_geometry(mANW.get(),
- texWidth, texHeight, HAL_PIXEL_FORMAT_RGBA_8888));
- ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(),
- GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN));
-
- android_native_buffer_t* anb;
- ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(),
- &anb));
- ASSERT_TRUE(anb != NULL);
-
- sp<GraphicBuffer> buf(new GraphicBuffer(anb, false));
-
- // Fill the buffer with green
- uint8_t* img = NULL;
- buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img));
- fillRGBA8BufferSolid(img, texWidth, texHeight, buf->getStride(), 0, 255,
- 0, 255);
- buf->unlock();
- ASSERT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), buf->getNativeBuffer(),
- -1));
-
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
-
- glBindFramebuffer(GL_FRAMEBUFFER, mFbo);
- drawTexture();
- glBindFramebuffer(GL_FRAMEBUFFER, 0);
-
- for (int i = 0; i < 4; i++) {
- SCOPED_TRACE(String8::format("frame %d", i).string());
-
- ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(mANW.get(),
- &anb));
- ASSERT_TRUE(anb != NULL);
-
- buf = new GraphicBuffer(anb, false);
-
- // Fill the buffer with red
- ASSERT_EQ(NO_ERROR, buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN,
- (void**)(&img)));
- fillRGBA8BufferSolid(img, texWidth, texHeight, buf->getStride(), 255, 0,
- 0, 255);
- ASSERT_EQ(NO_ERROR, buf->unlock());
- ASSERT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(),
- buf->getNativeBuffer(), -1));
-
- ASSERT_EQ(NO_ERROR, mST->updateTexImage());
-
- drawTexture();
-
- EXPECT_TRUE(checkPixel( 24, 39, 255, 0, 0, 255));
- }
-
- glBindFramebuffer(GL_FRAMEBUFFER, mFbo);
-
- EXPECT_TRUE(checkPixel( 24, 39, 0, 255, 0, 255));
-}
-
-class SurfaceTextureMultiContextGLTest : public SurfaceTextureGLTest {
-protected:
- enum { SECOND_TEX_ID = 123 };
- enum { THIRD_TEX_ID = 456 };
-
- SurfaceTextureMultiContextGLTest():
- mSecondEglContext(EGL_NO_CONTEXT) {
- }
-
- virtual void SetUp() {
- SurfaceTextureGLTest::SetUp();
-
- // Set up the secondary context and texture renderer.
- mSecondEglContext = eglCreateContext(mEglDisplay, mGlConfig,
- EGL_NO_CONTEXT, getContextAttribs());
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
- ASSERT_NE(EGL_NO_CONTEXT, mSecondEglContext);
-
- ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
- mSecondEglContext));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
- mSecondTextureRenderer = new TextureRenderer(SECOND_TEX_ID, mST);
- ASSERT_NO_FATAL_FAILURE(mSecondTextureRenderer->SetUp());
-
- // Set up the tertiary context and texture renderer.
- mThirdEglContext = eglCreateContext(mEglDisplay, mGlConfig,
- EGL_NO_CONTEXT, getContextAttribs());
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
- ASSERT_NE(EGL_NO_CONTEXT, mThirdEglContext);
-
- ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
- mThirdEglContext));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
- mThirdTextureRenderer = new TextureRenderer(THIRD_TEX_ID, mST);
- ASSERT_NO_FATAL_FAILURE(mThirdTextureRenderer->SetUp());
-
- // Switch back to the primary context to start the tests.
- ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
- mEglContext));
- }
-
- virtual void TearDown() {
- if (mThirdEglContext != EGL_NO_CONTEXT) {
- eglDestroyContext(mEglDisplay, mThirdEglContext);
- }
- if (mSecondEglContext != EGL_NO_CONTEXT) {
- eglDestroyContext(mEglDisplay, mSecondEglContext);
- }
- SurfaceTextureGLTest::TearDown();
- }
-
- EGLContext mSecondEglContext;
- sp<TextureRenderer> mSecondTextureRenderer;
-
- EGLContext mThirdEglContext;
- sp<TextureRenderer> mThirdTextureRenderer;
-};
-
-TEST_F(SurfaceTextureMultiContextGLTest, UpdateFromMultipleContextsFails) {
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
-
- // Latch the texture contents on the primary context.
- mFW->waitForFrame();
- ASSERT_EQ(OK, mST->updateTexImage());
-
- // Attempt to latch the texture on the secondary context.
- ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
- mSecondEglContext));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
- ASSERT_EQ(INVALID_OPERATION, mST->updateTexImage());
-}
-
-TEST_F(SurfaceTextureMultiContextGLTest, DetachFromContextSucceeds) {
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
-
- // Latch the texture contents on the primary context.
- mFW->waitForFrame();
- ASSERT_EQ(OK, mST->updateTexImage());
-
- // Detach from the primary context.
- ASSERT_EQ(OK, mST->detachFromContext());
-
- // Check that the GL texture was deleted.
- EXPECT_EQ(GL_FALSE, glIsTexture(TEX_ID));
-}
-
-TEST_F(SurfaceTextureMultiContextGLTest,
- DetachFromContextSucceedsAfterProducerDisconnect) {
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
-
- // Latch the texture contents on the primary context.
- mFW->waitForFrame();
- ASSERT_EQ(OK, mST->updateTexImage());
-
- // Detach from the primary context.
- native_window_api_disconnect(mANW.get(), NATIVE_WINDOW_API_CPU);
- ASSERT_EQ(OK, mST->detachFromContext());
-
- // Check that the GL texture was deleted.
- EXPECT_EQ(GL_FALSE, glIsTexture(TEX_ID));
-}
-
-TEST_F(SurfaceTextureMultiContextGLTest, DetachFromContextFailsWhenAbandoned) {
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
-
- // Latch the texture contents on the primary context.
- mFW->waitForFrame();
- ASSERT_EQ(OK, mST->updateTexImage());
-
- // Attempt to detach from the primary context.
- mST->abandon();
- ASSERT_EQ(NO_INIT, mST->detachFromContext());
-}
-
-TEST_F(SurfaceTextureMultiContextGLTest, DetachFromContextFailsWhenDetached) {
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
-
- // Latch the texture contents on the primary context.
- mFW->waitForFrame();
- ASSERT_EQ(OK, mST->updateTexImage());
-
- // Detach from the primary context.
- ASSERT_EQ(OK, mST->detachFromContext());
-
- // Attempt to detach from the primary context again.
- ASSERT_EQ(INVALID_OPERATION, mST->detachFromContext());
-}
-
-TEST_F(SurfaceTextureMultiContextGLTest, DetachFromContextFailsWithNoDisplay) {
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
-
- // Latch the texture contents on the primary context.
- mFW->waitForFrame();
- ASSERT_EQ(OK, mST->updateTexImage());
-
- // Make there be no current display.
- ASSERT_TRUE(eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
- EGL_NO_CONTEXT));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
-
- // Attempt to detach from the primary context.
- ASSERT_EQ(INVALID_OPERATION, mST->detachFromContext());
-}
-
-TEST_F(SurfaceTextureMultiContextGLTest, DetachFromContextFailsWithNoContext) {
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
-
- // Latch the texture contents on the primary context.
- mFW->waitForFrame();
- ASSERT_EQ(OK, mST->updateTexImage());
-
- // Make current context be incorrect.
- ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
- mSecondEglContext));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
-
- // Attempt to detach from the primary context.
- ASSERT_EQ(INVALID_OPERATION, mST->detachFromContext());
-}
-
-TEST_F(SurfaceTextureMultiContextGLTest, UpdateTexImageFailsWhenDetached) {
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
-
- // Detach from the primary context.
- ASSERT_EQ(OK, mST->detachFromContext());
-
- // Attempt to latch the texture contents on the primary context.
- mFW->waitForFrame();
- ASSERT_EQ(INVALID_OPERATION, mST->updateTexImage());
-}
-
-TEST_F(SurfaceTextureMultiContextGLTest, AttachToContextSucceeds) {
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
-
- // Latch the texture contents on the primary context.
- mFW->waitForFrame();
- ASSERT_EQ(OK, mST->updateTexImage());
-
- // Detach from the primary context.
- ASSERT_EQ(OK, mST->detachFromContext());
-
- // Attach to the secondary context.
- ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
- mSecondEglContext));
- ASSERT_EQ(OK, mST->attachToContext(SECOND_TEX_ID));
-
- // Verify that the texture object was created and bound.
- GLint texBinding = -1;
- glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, &texBinding);
- EXPECT_EQ(SECOND_TEX_ID, texBinding);
-
- // Try to use the texture from the secondary context.
- glClearColor(0.2, 0.2, 0.2, 0.2);
- glClear(GL_COLOR_BUFFER_BIT);
- glViewport(0, 0, 1, 1);
- mSecondTextureRenderer->drawTexture();
- ASSERT_TRUE(checkPixel( 0, 0, 35, 35, 35, 35));
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
-}
-
-TEST_F(SurfaceTextureMultiContextGLTest,
- AttachToContextSucceedsAfterProducerDisconnect) {
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
-
- // Latch the texture contents on the primary context.
- mFW->waitForFrame();
- ASSERT_EQ(OK, mST->updateTexImage());
-
- // Detach from the primary context.
- native_window_api_disconnect(mANW.get(), NATIVE_WINDOW_API_CPU);
- ASSERT_EQ(OK, mST->detachFromContext());
-
- // Attach to the secondary context.
- ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
- mSecondEglContext));
- ASSERT_EQ(OK, mST->attachToContext(SECOND_TEX_ID));
-
- // Verify that the texture object was created and bound.
- GLint texBinding = -1;
- glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, &texBinding);
- EXPECT_EQ(SECOND_TEX_ID, texBinding);
-
- // Try to use the texture from the secondary context.
- glClearColor(0.2, 0.2, 0.2, 0.2);
- glClear(GL_COLOR_BUFFER_BIT);
- glViewport(0, 0, 1, 1);
- mSecondTextureRenderer->drawTexture();
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
- ASSERT_TRUE(checkPixel( 0, 0, 35, 35, 35, 35));
-}
-
-TEST_F(SurfaceTextureMultiContextGLTest,
- AttachToContextSucceedsBeforeUpdateTexImage) {
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
-
- // Detach from the primary context.
- native_window_api_disconnect(mANW.get(), NATIVE_WINDOW_API_CPU);
- ASSERT_EQ(OK, mST->detachFromContext());
-
- // Attach to the secondary context.
- ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
- mSecondEglContext));
- ASSERT_EQ(OK, mST->attachToContext(SECOND_TEX_ID));
-
- // Verify that the texture object was created and bound.
- GLint texBinding = -1;
- glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, &texBinding);
- EXPECT_EQ(SECOND_TEX_ID, texBinding);
-
- // Latch the texture contents on the primary context.
- mFW->waitForFrame();
- ASSERT_EQ(OK, mST->updateTexImage());
-
- // Try to use the texture from the secondary context.
- glClearColor(0.2, 0.2, 0.2, 0.2);
- glClear(GL_COLOR_BUFFER_BIT);
- glViewport(0, 0, 1, 1);
- mSecondTextureRenderer->drawTexture();
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
- ASSERT_TRUE(checkPixel( 0, 0, 35, 35, 35, 35));
-}
-
-TEST_F(SurfaceTextureMultiContextGLTest, AttachToContextFailsWhenAbandoned) {
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
-
- // Latch the texture contents on the primary context.
- mFW->waitForFrame();
- ASSERT_EQ(OK, mST->updateTexImage());
-
- // Detach from the primary context.
- ASSERT_EQ(OK, mST->detachFromContext());
-
- // Attempt to attach to the secondary context.
- mST->abandon();
-
- // Attempt to attach to the primary context.
- ASSERT_EQ(NO_INIT, mST->attachToContext(SECOND_TEX_ID));
-}
-
-TEST_F(SurfaceTextureMultiContextGLTest, AttachToContextFailsWhenAttached) {
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
-
- // Latch the texture contents on the primary context.
- mFW->waitForFrame();
- ASSERT_EQ(OK, mST->updateTexImage());
-
- // Attempt to attach to the primary context.
- ASSERT_EQ(INVALID_OPERATION, mST->attachToContext(SECOND_TEX_ID));
-}
-
-TEST_F(SurfaceTextureMultiContextGLTest,
- AttachToContextFailsWhenAttachedBeforeUpdateTexImage) {
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
-
- // Attempt to attach to the primary context.
- ASSERT_EQ(INVALID_OPERATION, mST->attachToContext(SECOND_TEX_ID));
-}
-
-TEST_F(SurfaceTextureMultiContextGLTest, AttachToContextFailsWithNoDisplay) {
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
-
- // Latch the texture contents on the primary context.
- mFW->waitForFrame();
- ASSERT_EQ(OK, mST->updateTexImage());
-
- // Detach from the primary context.
- ASSERT_EQ(OK, mST->detachFromContext());
-
- // Make there be no current display.
- ASSERT_TRUE(eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
- EGL_NO_CONTEXT));
- ASSERT_EQ(EGL_SUCCESS, eglGetError());
-
- // Attempt to attach with no context current.
- ASSERT_EQ(INVALID_OPERATION, mST->attachToContext(SECOND_TEX_ID));
-}
-
-TEST_F(SurfaceTextureMultiContextGLTest, AttachToContextSucceedsTwice) {
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
-
- // Latch the texture contents on the primary context.
- mFW->waitForFrame();
- ASSERT_EQ(OK, mST->updateTexImage());
-
- // Detach from the primary context.
- ASSERT_EQ(OK, mST->detachFromContext());
-
- // Attach to the secondary context.
- ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
- mSecondEglContext));
- ASSERT_EQ(OK, mST->attachToContext(SECOND_TEX_ID));
-
- // Detach from the secondary context.
- ASSERT_EQ(OK, mST->detachFromContext());
-
- // Attach to the tertiary context.
- ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
- mThirdEglContext));
- ASSERT_EQ(OK, mST->attachToContext(THIRD_TEX_ID));
-
- // Verify that the texture object was created and bound.
- GLint texBinding = -1;
- glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, &texBinding);
- EXPECT_EQ(THIRD_TEX_ID, texBinding);
-
- // Try to use the texture from the tertiary context.
- glClearColor(0.2, 0.2, 0.2, 0.2);
- glClear(GL_COLOR_BUFFER_BIT);
- glViewport(0, 0, 1, 1);
- mThirdTextureRenderer->drawTexture();
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
- ASSERT_TRUE(checkPixel( 0, 0, 35, 35, 35, 35));
-}
-
-TEST_F(SurfaceTextureMultiContextGLTest,
- AttachToContextSucceedsTwiceBeforeUpdateTexImage) {
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
-
- // Detach from the primary context.
- ASSERT_EQ(OK, mST->detachFromContext());
-
- // Attach to the secondary context.
- ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
- mSecondEglContext));
- ASSERT_EQ(OK, mST->attachToContext(SECOND_TEX_ID));
-
- // Detach from the secondary context.
- ASSERT_EQ(OK, mST->detachFromContext());
-
- // Attach to the tertiary context.
- ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
- mThirdEglContext));
- ASSERT_EQ(OK, mST->attachToContext(THIRD_TEX_ID));
-
- // Verify that the texture object was created and bound.
- GLint texBinding = -1;
- glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, &texBinding);
- EXPECT_EQ(THIRD_TEX_ID, texBinding);
-
- // Latch the texture contents on the tertiary context.
- mFW->waitForFrame();
- ASSERT_EQ(OK, mST->updateTexImage());
-
- // Try to use the texture from the tertiary context.
- glClearColor(0.2, 0.2, 0.2, 0.2);
- glClear(GL_COLOR_BUFFER_BIT);
- glViewport(0, 0, 1, 1);
- mThirdTextureRenderer->drawTexture();
- ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
- ASSERT_TRUE(checkPixel( 0, 0, 35, 35, 35, 35));
-}
-
-TEST_F(SurfaceTextureMultiContextGLTest,
- UpdateTexImageSucceedsForBufferConsumedBeforeDetach) {
- ASSERT_EQ(NO_ERROR, mST->setDefaultMaxBufferCount(2));
-
- // produce two frames and consume them both on the primary context
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
- mFW->waitForFrame();
- ASSERT_EQ(OK, mST->updateTexImage());
-
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
- mFW->waitForFrame();
- ASSERT_EQ(OK, mST->updateTexImage());
-
- // produce one more frame
- ASSERT_NO_FATAL_FAILURE(produceOneRGBA8Frame(mANW));
-
- // Detach from the primary context and attach to the secondary context
- ASSERT_EQ(OK, mST->detachFromContext());
- ASSERT_TRUE(eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
- mSecondEglContext));
- ASSERT_EQ(OK, mST->attachToContext(SECOND_TEX_ID));
-
- // Consume final frame on secondary context
- mFW->waitForFrame();
- ASSERT_EQ(OK, mST->updateTexImage());
-}
-
-} // namespace android
diff --git a/libs/gui/tests/TextureRenderer.cpp b/libs/gui/tests/TextureRenderer.cpp
new file mode 100644
index 0000000..90951b3
--- /dev/null
+++ b/libs/gui/tests/TextureRenderer.cpp
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "TextureRenderer.h"
+
+#include "GLTest.h"
+
+#include <gui/GLConsumer.h>
+
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
+#include <gtest/gtest.h>
+
+namespace android {
+
+TextureRenderer::TextureRenderer(GLuint texName,
+ const sp<GLConsumer>& st) : mTexName(texName), mST(st) {
+}
+
+void TextureRenderer::SetUp() {
+ const char vsrc[] =
+ "attribute vec4 vPosition;\n"
+ "varying vec2 texCoords;\n"
+ "uniform mat4 texMatrix;\n"
+ "void main() {\n"
+ " vec2 vTexCoords = 0.5 * (vPosition.xy + vec2(1.0, 1.0));\n"
+ " texCoords = (texMatrix * vec4(vTexCoords, 0.0, 1.0)).xy;\n"
+ " gl_Position = vPosition;\n"
+ "}\n";
+
+ const char fsrc[] =
+ "#extension GL_OES_EGL_image_external : require\n"
+ "precision mediump float;\n"
+ "uniform samplerExternalOES texSampler;\n"
+ "varying vec2 texCoords;\n"
+ "void main() {\n"
+ " gl_FragColor = texture2D(texSampler, texCoords);\n"
+ "}\n";
+
+ {
+ SCOPED_TRACE("creating shader program");
+ ASSERT_NO_FATAL_FAILURE(GLTest::createProgram(vsrc, fsrc, &mPgm));
+ }
+
+ mPositionHandle = glGetAttribLocation(mPgm, "vPosition");
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+ ASSERT_NE(-1, mPositionHandle);
+ mTexSamplerHandle = glGetUniformLocation(mPgm, "texSampler");
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+ ASSERT_NE(-1, mTexSamplerHandle);
+ mTexMatrixHandle = glGetUniformLocation(mPgm, "texMatrix");
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+ ASSERT_NE(-1, mTexMatrixHandle);
+}
+
+// drawTexture draws the GLConsumer over the entire GL viewport.
+void TextureRenderer::drawTexture() {
+ static const GLfloat triangleVertices[] = {
+ -1.0f, 1.0f,
+ -1.0f, -1.0f,
+ 1.0f, -1.0f,
+ 1.0f, 1.0f,
+ };
+
+ glVertexAttribPointer(mPositionHandle, 2, GL_FLOAT, GL_FALSE, 0,
+ triangleVertices);
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+ glEnableVertexAttribArray(mPositionHandle);
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+
+ glUseProgram(mPgm);
+ glUniform1i(mTexSamplerHandle, 0);
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+ glBindTexture(GL_TEXTURE_EXTERNAL_OES, mTexName);
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+
+ // XXX: These calls are not needed for GL_TEXTURE_EXTERNAL_OES as
+ // they're setting the defautls for that target, but when hacking
+ // things to use GL_TEXTURE_2D they are needed to achieve the same
+ // behavior.
+ glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER,
+ GL_LINEAR);
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+ glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER,
+ GL_LINEAR);
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+ glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S,
+ GL_CLAMP_TO_EDGE);
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+ glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T,
+ GL_CLAMP_TO_EDGE);
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+
+ GLfloat texMatrix[16];
+ mST->getTransformMatrix(texMatrix);
+ glUniformMatrix4fv(mTexMatrixHandle, 1, GL_FALSE, texMatrix);
+
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+ ASSERT_EQ(GLenum(GL_NO_ERROR), glGetError());
+}
+
+} // namespace android
diff --git a/libs/gui/tests/TextureRenderer.h b/libs/gui/tests/TextureRenderer.h
new file mode 100644
index 0000000..37b2b47
--- /dev/null
+++ b/libs/gui/tests/TextureRenderer.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_TEXTURE_RENDERER_H
+#define ANDROID_TEXTURE_RENDERER_H
+
+#include <GLES/gl.h>
+
+#include <utils/RefBase.h>
+
+namespace android {
+
+class GLConsumer;
+
+class TextureRenderer : public RefBase {
+public:
+ TextureRenderer(GLuint texName, const sp<GLConsumer>& st);
+
+ void SetUp();
+ void drawTexture();
+
+private:
+ GLuint mTexName;
+ sp<GLConsumer> mST;
+ GLuint mPgm;
+ GLint mPositionHandle;
+ GLint mTexSamplerHandle;
+ GLint mTexMatrixHandle;
+};
+
+} // namespace android
+
+#endif