Initial import of VNCFlinger
diff --git a/src/EglWindow.cpp b/src/EglWindow.cpp
new file mode 100644
index 0000000..c534b02
--- /dev/null
+++ b/src/EglWindow.cpp
@@ -0,0 +1,189 @@
+/*
+ * 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 "VNC-EglWindow"
+//#define LOG_NDEBUG 0
+#include <utils/Log.h>
+
+#define EGL_EGLEXT_PROTOTYPES
+
+#include <gui/BufferQueue.h>
+#include <gui/GraphicBufferAlloc.h>
+#include <gui/Surface.h>
+
+#include "EglWindow.h"
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+
+#include <assert.h>
+
+using namespace android;
+
+
+status_t EglWindow::createWindow(const sp<IGraphicBufferProducer>& surface) {
+ if (mEglSurface != EGL_NO_SURFACE) {
+ ALOGE("surface already created");
+ return UNKNOWN_ERROR;
+ }
+ status_t err = eglSetupContext(false);
+ if (err != NO_ERROR) {
+ return err;
+ }
+
+ // Cache the current dimensions. We're not expecting these to change.
+ surface->query(NATIVE_WINDOW_WIDTH, &mWidth);
+ surface->query(NATIVE_WINDOW_HEIGHT, &mHeight);
+
+ // Output side (EGL surface to draw on).
+ sp<ANativeWindow> anw = new Surface(surface);
+ mEglSurface = eglCreateWindowSurface(mEglDisplay, mEglConfig, anw.get(),
+ NULL);
+ if (mEglSurface == EGL_NO_SURFACE) {
+ ALOGE("eglCreateWindowSurface error: %#x", eglGetError());
+ eglRelease();
+ return UNKNOWN_ERROR;
+ }
+
+ return NO_ERROR;
+}
+
+status_t EglWindow::createPbuffer(int width, int height) {
+ if (mEglSurface != EGL_NO_SURFACE) {
+ ALOGE("surface already created");
+ return UNKNOWN_ERROR;
+ }
+ status_t err = eglSetupContext(true);
+ if (err != NO_ERROR) {
+ return err;
+ }
+
+ mWidth = width;
+ mHeight = height;
+
+ EGLint pbufferAttribs[] = {
+ EGL_WIDTH, width,
+ EGL_HEIGHT, height,
+ EGL_NONE
+ };
+ mEglSurface = eglCreatePbufferSurface(mEglDisplay, mEglConfig, pbufferAttribs);
+ if (mEglSurface == EGL_NO_SURFACE) {
+ ALOGE("eglCreatePbufferSurface error: %#x", eglGetError());
+ eglRelease();
+ return UNKNOWN_ERROR;
+ }
+
+ return NO_ERROR;
+}
+
+status_t EglWindow::makeCurrent() const {
+ if (!eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {
+ ALOGE("eglMakeCurrent failed: %#x", eglGetError());
+ return UNKNOWN_ERROR;
+ }
+ return NO_ERROR;
+}
+
+status_t EglWindow::eglSetupContext(bool forPbuffer) {
+ EGLBoolean result;
+
+ mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+ if (mEglDisplay == EGL_NO_DISPLAY) {
+ ALOGE("eglGetDisplay failed: %#x", eglGetError());
+ return UNKNOWN_ERROR;
+ }
+
+ EGLint majorVersion, minorVersion;
+ result = eglInitialize(mEglDisplay, &majorVersion, &minorVersion);
+ if (result != EGL_TRUE) {
+ ALOGE("eglInitialize failed: %#x", eglGetError());
+ return UNKNOWN_ERROR;
+ }
+ ALOGV("Initialized EGL v%d.%d", majorVersion, minorVersion);
+
+ EGLint numConfigs = 0;
+ EGLint windowConfigAttribs[] = {
+ EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+ EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+ EGL_RECORDABLE_ANDROID, 1,
+ EGL_RED_SIZE, 8,
+ EGL_GREEN_SIZE, 8,
+ EGL_BLUE_SIZE, 8,
+ EGL_ALPHA_SIZE, 8,
+ };
+ EGLint pbufferConfigAttribs[] = {
+ EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
+ EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+ EGL_RED_SIZE, 8,
+ EGL_GREEN_SIZE, 8,
+ EGL_BLUE_SIZE, 8,
+ EGL_ALPHA_SIZE, 8,
+ EGL_NONE
+ };
+ result = eglChooseConfig(mEglDisplay,
+ forPbuffer ? pbufferConfigAttribs : windowConfigAttribs,
+ &mEglConfig, 1, &numConfigs);
+ if (result != EGL_TRUE) {
+ ALOGE("eglChooseConfig error: %#x", eglGetError());
+ return UNKNOWN_ERROR;
+ }
+
+ EGLint contextAttribs[] = {
+ EGL_CONTEXT_CLIENT_VERSION, 2,
+ EGL_NONE
+ };
+ mEglContext = eglCreateContext(mEglDisplay, mEglConfig, EGL_NO_CONTEXT,
+ contextAttribs);
+ if (mEglContext == EGL_NO_CONTEXT) {
+ ALOGE("eglCreateContext error: %#x", eglGetError());
+ return UNKNOWN_ERROR;
+ }
+
+ return NO_ERROR;
+}
+
+void EglWindow::eglRelease() {
+ ALOGV("EglWindow::eglRelease");
+ if (mEglDisplay != EGL_NO_DISPLAY) {
+ eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
+ EGL_NO_CONTEXT);
+
+ if (mEglContext != EGL_NO_CONTEXT) {
+ eglDestroyContext(mEglDisplay, mEglContext);
+ }
+
+ if (mEglSurface != EGL_NO_SURFACE) {
+ eglDestroySurface(mEglDisplay, mEglSurface);
+ }
+ }
+
+ mEglDisplay = EGL_NO_DISPLAY;
+ mEglContext = EGL_NO_CONTEXT;
+ mEglSurface = EGL_NO_SURFACE;
+ mEglConfig = NULL;
+
+ eglReleaseThread();
+}
+
+// Sets the presentation time on the current EGL buffer.
+void EglWindow::presentationTime(nsecs_t whenNsec) const {
+ eglPresentationTimeANDROID(mEglDisplay, mEglSurface, whenNsec);
+}
+
+// Swaps the EGL buffer.
+void EglWindow::swapBuffers() const {
+ eglSwapBuffers(mEglDisplay, mEglSurface);
+}
diff --git a/src/EglWindow.h b/src/EglWindow.h
new file mode 100644
index 0000000..69d0c31
--- /dev/null
+++ b/src/EglWindow.h
@@ -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.
+ */
+
+#ifndef SCREENRECORD_EGL_WINDOW_H
+#define SCREENRECORD_EGL_WINDOW_H
+
+#include <gui/BufferQueue.h>
+#include <utils/Errors.h>
+
+#include <EGL/egl.h>
+
+namespace android {
+
+/*
+ * Wraps EGL display, context, surface, config for a window surface.
+ *
+ * Not thread safe.
+ */
+class EglWindow {
+public:
+ EglWindow() :
+ mEglDisplay(EGL_NO_DISPLAY),
+ mEglContext(EGL_NO_CONTEXT),
+ mEglSurface(EGL_NO_SURFACE),
+ mEglConfig(NULL),
+ mWidth(0),
+ mHeight(0)
+ {}
+ ~EglWindow() { eglRelease(); }
+
+ // Creates an EGL window for the supplied surface.
+ status_t createWindow(const sp<IGraphicBufferProducer>& surface);
+
+ // Creates an EGL pbuffer surface.
+ status_t createPbuffer(int width, int height);
+
+ // Return width and height values (obtained from IGBP).
+ int getWidth() const { return mWidth; }
+ int getHeight() const { return mHeight; }
+
+ // Release anything we created.
+ void release() { eglRelease(); }
+
+ // Make this context current.
+ status_t makeCurrent() const;
+
+ // Sets the presentation time on the current EGL buffer.
+ void presentationTime(nsecs_t whenNsec) const;
+
+ // Swaps the EGL buffer.
+ void swapBuffers() const;
+
+private:
+ EglWindow(const EglWindow&);
+ EglWindow& operator=(const EglWindow&);
+
+ // Init display, create config and context.
+ status_t eglSetupContext(bool forPbuffer);
+ void eglRelease();
+
+ // Basic EGL goodies.
+ EGLDisplay mEglDisplay;
+ EGLContext mEglContext;
+ EGLSurface mEglSurface;
+ EGLConfig mEglConfig;
+
+ // Surface dimensions.
+ int mWidth;
+ int mHeight;
+};
+
+}; // namespace android
+
+#endif /*SCREENRECORD_EGL_WINDOW_H*/
diff --git a/src/EventQueue.cpp b/src/EventQueue.cpp
new file mode 100644
index 0000000..a107f30
--- /dev/null
+++ b/src/EventQueue.cpp
@@ -0,0 +1,59 @@
+#define LOG_TAG "VNC-EventQueue"
+#include <utils/Log.h>
+
+#include "EventQueue.h"
+
+using namespace android;
+
+void EventQueue::enqueue(const Event& event) {
+ mQueue.push(event);
+ ALOGV("enqueue: mId=%d mData=%p qlen=%zu", event.mId, event.mData, mQueue.size());
+
+ Mutex::Autolock _l(mMutex);
+ mCondition.broadcast();
+}
+
+void EventQueue::await() {
+ Mutex::Autolock _l(mMutex);
+
+ while (mRunning) {
+ ALOGV("begin wait");
+ mCondition.wait(mMutex);
+
+ ALOGV("queue active");
+ while (!mQueue.empty()) {
+ Event event = mQueue.front();
+ mQueue.pop();
+
+ mMutex.unlock();
+ for (std::vector<EventListener *>::iterator it = mListeners.begin();
+ it != mListeners.end(); ++it) {
+ ALOGV("call listener: %p", *it);
+ (*it)->onEvent(event);
+ }
+ mMutex.lock();
+
+ }
+ }
+}
+
+void EventQueue::shutdown() {
+ Mutex::Autolock _l(mMutex);
+ flush();
+ mRunning = false;
+ mCondition.broadcast();
+}
+
+void EventQueue::flush() {
+ Mutex::Autolock _l(mMutex);
+ mQueue = {};
+}
+
+void EventQueue::addListener(EventListener *listener) {
+ mListeners.push_back(listener);
+ ALOGV("addListener: %p", listener);
+}
+
+void EventQueue::removeListener(EventListener *listener) {
+ mListeners.erase(std::remove(mListeners.begin(), mListeners.end(), listener), mListeners.end());
+}
diff --git a/src/EventQueue.h b/src/EventQueue.h
new file mode 100644
index 0000000..e926831
--- /dev/null
+++ b/src/EventQueue.h
@@ -0,0 +1,67 @@
+#ifndef MQ_H
+#define MQ_H
+
+#include <queue>
+#include <vector>
+
+#include <utils/RefBase.h>
+#include <utils/Thread.h>
+
+#define EVENT_CLIENT_CONNECT 0
+#define EVENT_CLIENT_GONE 1
+#define EVENT_BUFFER_READY 2
+
+namespace android {
+
+class Event {
+public:
+ Event(unsigned int id, void* data = 0):
+ mId(id),
+ mData(data) {}
+
+ Event(const Event& ev):
+ mId(ev.mId),
+ mData(ev.mData) {}
+
+ unsigned int mId;
+ void* mData;
+};
+
+class EventListener {
+public:
+ virtual ~EventListener() {}
+
+ virtual void onEvent(const Event& event) = 0;
+};
+
+class EventQueue : public RefBase {
+public:
+ EventQueue():
+ mRunning(true) {}
+
+ virtual void await();
+
+ virtual void shutdown();
+
+ virtual void enqueue(const Event& event);
+
+ virtual void flush();
+
+ virtual void addListener(EventListener *listener);
+
+ virtual void removeListener(EventListener *listener);
+
+ virtual ~EventQueue() { }
+
+private:
+ Mutex mMutex;
+ Condition mCondition;
+
+ std::queue<const Event> mQueue;
+ std::vector<EventListener *> mListeners;
+
+ bool mRunning;
+};
+
+};
+#endif
diff --git a/src/Program.cpp b/src/Program.cpp
new file mode 100644
index 0000000..72c11aa
--- /dev/null
+++ b/src/Program.cpp
@@ -0,0 +1,307 @@
+/*
+ * 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 "VNC"
+//#define LOG_NDEBUG 0
+#include <utils/Log.h>
+
+#include "Program.h"
+
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
+#include <assert.h>
+
+using namespace android;
+
+// 4x4 identity matrix
+const float Program::kIdentity[] = {
+ 1.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 1.0f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 1.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 1.0f
+};
+
+// Simple vertex shader. Texture coord calc includes matrix for GLConsumer
+// transform.
+static const char* kVertexShader =
+ "uniform mat4 uMVPMatrix;\n"
+ "uniform mat4 uGLCMatrix;\n"
+ "attribute vec4 aPosition;\n"
+ "attribute vec4 aTextureCoord;\n"
+ "varying vec2 vTextureCoord;\n"
+ "void main() {\n"
+ " gl_Position = uMVPMatrix * aPosition;\n"
+ " vTextureCoord = (uGLCMatrix * aTextureCoord).xy;\n"
+ "}\n";
+
+// Trivial fragment shader for external texture.
+static const char* kExtFragmentShader =
+ "#extension GL_OES_EGL_image_external : require\n"
+ "precision mediump float;\n"
+ "varying vec2 vTextureCoord;\n"
+ "uniform samplerExternalOES uTexture;\n"
+ "void main() {\n"
+ " gl_FragColor = texture2D(uTexture, vTextureCoord);\n"
+ "}\n";
+
+// Trivial fragment shader for mundane texture.
+static const char* kFragmentShader =
+ "precision mediump float;\n"
+ "varying vec2 vTextureCoord;\n"
+ "uniform sampler2D uTexture;\n"
+ "void main() {\n"
+ " gl_FragColor = texture2D(uTexture, vTextureCoord);\n"
+ //" gl_FragColor = vec4(0.2, 1.0, 0.2, 1.0);\n"
+ "}\n";
+
+status_t Program::setup(ProgramType type) {
+ ALOGV("Program::setup type=%d", type);
+ status_t err;
+
+ mProgramType = type;
+
+ GLuint program;
+ if (type == PROGRAM_TEXTURE_2D) {
+ err = createProgram(&program, kVertexShader, kFragmentShader);
+ } else {
+ err = createProgram(&program, kVertexShader, kExtFragmentShader);
+ }
+ if (err != NO_ERROR) {
+ return err;
+ }
+ assert(program != 0);
+
+ maPositionLoc = glGetAttribLocation(program, "aPosition");
+ maTextureCoordLoc = glGetAttribLocation(program, "aTextureCoord");
+ muMVPMatrixLoc = glGetUniformLocation(program, "uMVPMatrix");
+ muGLCMatrixLoc = glGetUniformLocation(program, "uGLCMatrix");
+ muTextureLoc = glGetUniformLocation(program, "uTexture");
+ if ((maPositionLoc | maTextureCoordLoc | muMVPMatrixLoc |
+ muGLCMatrixLoc | muTextureLoc) == -1) {
+ ALOGE("Attrib/uniform lookup failed: %#x", glGetError());
+ glDeleteProgram(program);
+ return UNKNOWN_ERROR;
+ }
+
+ mProgram = program;
+ return NO_ERROR;
+}
+
+void Program::release() {
+ ALOGV("Program::release");
+ if (mProgram != 0) {
+ glDeleteProgram(mProgram);
+ mProgram = 0;
+ }
+}
+
+status_t Program::createProgram(GLuint* outPgm, const char* vertexShader,
+ const char* fragmentShader) {
+ GLuint vs, fs;
+ status_t err;
+
+ err = compileShader(GL_VERTEX_SHADER, vertexShader, &vs);
+ if (err != NO_ERROR) {
+ return err;
+ }
+ err = compileShader(GL_FRAGMENT_SHADER, fragmentShader, &fs);
+ if (err != NO_ERROR) {
+ glDeleteShader(vs);
+ return err;
+ }
+
+ GLuint program;
+ err = linkShaderProgram(vs, fs, &program);
+ glDeleteShader(vs);
+ glDeleteShader(fs);
+ if (err == NO_ERROR) {
+ *outPgm = program;
+ }
+ return err;
+}
+
+status_t Program::compileShader(GLenum shaderType, const char* src,
+ GLuint* outShader) {
+ GLuint shader = glCreateShader(shaderType);
+ if (shader == 0) {
+ ALOGE("glCreateShader error: %#x", glGetError());
+ return UNKNOWN_ERROR;
+ }
+
+ glShaderSource(shader, 1, &src, NULL);
+ glCompileShader(shader);
+
+ GLint compiled = 0;
+ glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+ if (!compiled) {
+ ALOGE("Compile of shader type %d failed", shaderType);
+ GLint infoLen = 0;
+ glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
+ if (infoLen) {
+ char* buf = new char[infoLen];
+ if (buf) {
+ glGetShaderInfoLog(shader, infoLen, NULL, buf);
+ ALOGE("Compile log: %s", buf);
+ delete[] buf;
+ }
+ }
+ glDeleteShader(shader);
+ return UNKNOWN_ERROR;
+ }
+ *outShader = shader;
+ return NO_ERROR;
+}
+
+status_t Program::linkShaderProgram(GLuint vs, GLuint fs, GLuint* outPgm) {
+ GLuint program = glCreateProgram();
+ if (program == 0) {
+ ALOGE("glCreateProgram error: %#x", glGetError());
+ return UNKNOWN_ERROR;
+ }
+
+ glAttachShader(program, vs);
+ glAttachShader(program, fs);
+ glLinkProgram(program);
+ GLint linkStatus = GL_FALSE;
+ glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
+ if (linkStatus != GL_TRUE) {
+ ALOGE("glLinkProgram failed");
+ GLint bufLength = 0;
+ glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
+ if (bufLength) {
+ char* buf = new char[bufLength];
+ if (buf) {
+ glGetProgramInfoLog(program, bufLength, NULL, buf);
+ ALOGE("Link log: %s", buf);
+ delete[] buf;
+ }
+ }
+ glDeleteProgram(program);
+ return UNKNOWN_ERROR;
+ }
+
+ *outPgm = program;
+ return NO_ERROR;
+}
+
+
+
+status_t Program::blit(GLuint texName, const float* texMatrix,
+ int32_t x, int32_t y, int32_t w, int32_t h, bool invert) const {
+ ALOGV("Program::blit %d xy=%d,%d wh=%d,%d", texName, x, y, w, h);
+
+ const float pos[] = {
+ float(x), float(y+h),
+ float(x+w), float(y+h),
+ float(x), float(y),
+ float(x+w), float(y),
+ };
+ const float uv[] = {
+ 0.0f, 0.0f,
+ 1.0f, 0.0f,
+ 0.0f, 1.0f,
+ 1.0f, 1.0f,
+ };
+ status_t err;
+
+ err = beforeDraw(texName, texMatrix, pos, uv, invert);
+ if (err == NO_ERROR) {
+ glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+ err = afterDraw();
+ }
+ return err;
+}
+
+status_t Program::drawTriangles(GLuint texName, const float* texMatrix,
+ const float* vertices, const float* texes, size_t count) const {
+ ALOGV("Program::drawTriangles texName=%d", texName);
+
+ status_t err;
+
+ err = beforeDraw(texName, texMatrix, vertices, texes, false);
+ if (err == NO_ERROR) {
+ glDrawArrays(GL_TRIANGLES, 0, count);
+ err = afterDraw();
+ }
+ return err;
+}
+
+status_t Program::beforeDraw(GLuint texName, const float* texMatrix,
+ const float* vertices, const float* texes, bool invert) const {
+ // Create an orthographic projection matrix based on viewport size.
+ GLint vp[4];
+ glGetIntegerv(GL_VIEWPORT, vp);
+ float screenToNdc[16] = {
+ 2.0f/float(vp[2]), 0.0f, 0.0f, 0.0f,
+ 0.0f, -2.0f/float(vp[3]), 0.0f, 0.0f,
+ 0.0f, 0.0f, 1.0f, 0.0f,
+ -1.0f, 1.0f, 0.0f, 1.0f,
+ };
+ if (invert) {
+ screenToNdc[5] = -screenToNdc[5];
+ screenToNdc[13] = -screenToNdc[13];
+ }
+
+ glUseProgram(mProgram);
+
+ glVertexAttribPointer(maPositionLoc, 2, GL_FLOAT, GL_FALSE, 0, vertices);
+ glVertexAttribPointer(maTextureCoordLoc, 2, GL_FLOAT, GL_FALSE, 0, texes);
+ glEnableVertexAttribArray(maPositionLoc);
+ glEnableVertexAttribArray(maTextureCoordLoc);
+
+ glUniformMatrix4fv(muMVPMatrixLoc, 1, GL_FALSE, screenToNdc);
+ glUniformMatrix4fv(muGLCMatrixLoc, 1, GL_FALSE, texMatrix);
+
+ glActiveTexture(GL_TEXTURE0);
+
+ switch (mProgramType) {
+ case PROGRAM_EXTERNAL_TEXTURE:
+ glBindTexture(GL_TEXTURE_EXTERNAL_OES, texName);
+ break;
+ case PROGRAM_TEXTURE_2D:
+ glBindTexture(GL_TEXTURE_2D, texName);
+ break;
+ default:
+ ALOGE("unexpected program type %d", mProgramType);
+ return UNKNOWN_ERROR;
+ }
+
+ glUniform1i(muTextureLoc, 0);
+
+ GLenum glErr;
+ if ((glErr = glGetError()) != GL_NO_ERROR) {
+ ALOGE("GL error before draw: %#x", glErr);
+ glDisableVertexAttribArray(maPositionLoc);
+ glDisableVertexAttribArray(maTextureCoordLoc);
+ return UNKNOWN_ERROR;
+ }
+
+ return NO_ERROR;
+}
+
+status_t Program::afterDraw() const {
+ glDisableVertexAttribArray(maPositionLoc);
+ glDisableVertexAttribArray(maTextureCoordLoc);
+
+ GLenum glErr;
+ if ((glErr = glGetError()) != GL_NO_ERROR) {
+ ALOGE("GL error after draw: %#x", glErr);
+ return UNKNOWN_ERROR;
+ }
+
+ return NO_ERROR;
+}
diff --git a/src/Program.h b/src/Program.h
new file mode 100644
index 0000000..558be8d
--- /dev/null
+++ b/src/Program.h
@@ -0,0 +1,94 @@
+/*
+ * 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 SCREENRECORD_PROGRAM_H
+#define SCREENRECORD_PROGRAM_H
+
+#include <utils/Errors.h>
+
+#include <EGL/egl.h>
+#include <GLES2/gl2.h>
+
+namespace android {
+
+/*
+ * Utility class for GLES rendering.
+ *
+ * Not thread-safe.
+ */
+class Program {
+public:
+ enum ProgramType { PROGRAM_UNKNOWN=0, PROGRAM_EXTERNAL_TEXTURE,
+ PROGRAM_TEXTURE_2D };
+
+ Program() :
+ mProgramType(PROGRAM_UNKNOWN),
+ mProgram(0),
+ maPositionLoc(0),
+ maTextureCoordLoc(0),
+ muMVPMatrixLoc(0),
+ muGLCMatrixLoc(0),
+ muTextureLoc(0)
+ {}
+ ~Program() { release(); }
+
+ // Initialize the program for use with the specified texture type.
+ status_t setup(ProgramType type);
+
+ // Release the program and associated resources.
+ void release();
+
+ // Blit the specified texture to { x, y, x+w, y+h }. Inverts the
+ // content if "invert" is set.
+ status_t blit(GLuint texName, const float* texMatrix,
+ int32_t x, int32_t y, int32_t w, int32_t h,
+ bool invert = false) const;
+
+ // Draw a number of triangles.
+ status_t drawTriangles(GLuint texName, const float* texMatrix,
+ const float* vertices, const float* texes, size_t count) const;
+
+ static const float kIdentity[];
+
+private:
+ Program(const Program&);
+ Program& operator=(const Program&);
+
+ // Common code for draw functions.
+ status_t beforeDraw(GLuint texName, const float* texMatrix,
+ const float* vertices, const float* texes, bool invert) const;
+ status_t afterDraw() const;
+
+ // GLES 2 shader utilities.
+ status_t createProgram(GLuint* outPgm, const char* vertexShader,
+ const char* fragmentShader);
+ static status_t compileShader(GLenum shaderType, const char* src,
+ GLuint* outShader);
+ static status_t linkShaderProgram(GLuint vs, GLuint fs, GLuint* outPgm);
+
+ ProgramType mProgramType;
+ GLuint mProgram;
+
+ GLint maPositionLoc;
+ GLint maTextureCoordLoc;
+ GLint muMVPMatrixLoc;
+ GLint muGLCMatrixLoc;
+ GLint muTextureLoc;
+};
+
+}; // namespace android
+
+#endif /*SCREENRECORD_PROGRAM_H*/
diff --git a/src/README b/src/README
new file mode 100644
index 0000000..e6cbb2b
--- /dev/null
+++ b/src/README
@@ -0,0 +1,2 @@
+- The surfaceflinger method is present from version 2.3.X and should be supported by all devices.
+- It connects with the surfaceflinger service through a Binder interface.
diff --git a/src/VNCFlinger.cpp b/src/VNCFlinger.cpp
new file mode 100644
index 0000000..a55b868
--- /dev/null
+++ b/src/VNCFlinger.cpp
@@ -0,0 +1,165 @@
+#define LOG_TAG "VNCFlinger"
+#include <utils/Log.h>
+
+#include <binder/IPCThreadState.h>
+#include <binder/ProcessState.h>
+#include <binder/IServiceManager.h>
+
+#include <gui/ISurfaceComposer.h>
+#include <gui/SurfaceComposerClient.h>
+#include <gui/IGraphicBufferProducer.h>
+
+#include "VNCFlinger.h"
+
+using namespace android;
+
+EventQueue *VNCFlinger::sQueue = new EventQueue();
+
+status_t VNCFlinger::start() {
+ Mutex::Autolock _l(mMutex);
+
+ status_t err = setup_l();
+ if (err != NO_ERROR) {
+ ALOGE("Failed to start VNCFlinger: err=%d", err);
+ return err;
+ }
+
+ ALOGD("VNCFlinger is running!");
+
+ rfbRunEventLoop(mVNCScreen, -1, true);
+ sQueue->await();
+
+ release_l();
+ return NO_ERROR;
+}
+
+status_t VNCFlinger::setup_l() {
+
+ status_t err = NO_ERROR;
+
+ mMainDpy = SurfaceComposerClient::getBuiltInDisplay(
+ ISurfaceComposer::eDisplayIdMain);
+ err = SurfaceComposerClient::getDisplayInfo(mMainDpy, &mMainDpyInfo);
+ if (err != NO_ERROR) {
+ ALOGE("Unable to get display characteristics\n");
+ return err;
+ }
+
+ bool rotated = VirtualDisplay::isDeviceRotated(mMainDpyInfo.orientation);
+ if (mWidth == 0) {
+ mWidth = rotated ? mMainDpyInfo.h : mMainDpyInfo.w;
+ }
+ if (mHeight == 0) {
+ mHeight = rotated ? mMainDpyInfo.w : mMainDpyInfo.h;
+ }
+
+ ALOGD("Display dimensions: %dx%d rotated=%d", mWidth, mHeight, rotated);
+
+ sQueue->addListener(this);
+
+ mVirtualDisplay = new VirtualDisplay();
+
+ mVNCBuf = new uint8_t[mWidth * mHeight * 4];
+
+ rfbLog = VNCFlinger::rfbLogger;
+ rfbErr = VNCFlinger::rfbLogger;
+
+ // 32-bit color
+ mVNCScreen = rfbGetScreen(&mArgc, mArgv, mWidth, mHeight, 8, 3, 4);
+ if (mVNCScreen == NULL) {
+ ALOGE("Unable to create VNCScreen");
+ return NO_INIT;
+ }
+
+ mVNCScreen->desktopName = "VNCFlinger";
+ mVNCScreen->frameBuffer = (char *)mVNCBuf;
+ mVNCScreen->alwaysShared = TRUE;
+ mVNCScreen->httpDir = NULL;
+ mVNCScreen->port = VNC_PORT;
+ mVNCScreen->newClientHook = (rfbNewClientHookPtr) VNCFlinger::onNewClient;
+ mVNCScreen->serverFormat.trueColour = true;
+ mVNCScreen->serverFormat.bitsPerPixel = 32;
+ mVNCScreen->handleEventsEagerly = true;
+ mVNCScreen->deferUpdateTime = 5;
+
+ rfbInitServer(mVNCScreen);
+
+ /* Mark as dirty since we haven't sent any updates at all yet. */
+ rfbMarkRectAsModified(mVNCScreen, 0, 0, mWidth, mHeight);
+
+ return err;
+}
+
+void VNCFlinger::release_l() {
+ sQueue->removeListener(this);
+ mVirtualDisplay.clear();
+
+ ALOGD("VNCFlinger released");
+}
+
+status_t VNCFlinger::stop() {
+ Mutex::Autolock _l(mMutex);
+ sQueue->shutdown();
+
+ return NO_ERROR;
+}
+
+void VNCFlinger::onEvent(const Event& event) {
+
+ ALOGV("onEvent: mId=%d mData=%p", event.mId, event.mData);
+
+ switch(event.mId) {
+ case EVENT_CLIENT_CONNECT:
+ if (mClientCount == 0) {
+ mVirtualDisplay->start(mMainDpyInfo, sQueue);
+ }
+ mClientCount++;
+
+ ALOGI("Client connected (%zu)", mClientCount);
+ break;
+
+ case EVENT_CLIENT_GONE:
+ if (mClientCount > 0) {
+ mClientCount--;
+ if (mClientCount == 0) {
+ mVirtualDisplay->stop();
+ }
+ }
+
+ ALOGI("Client disconnected (%zu)", mClientCount);
+ break;
+
+ case EVENT_BUFFER_READY:
+ //mVNCScreen->frameBuffer = (char *) event.mData;
+ memcpy(mVNCBuf, (uint8_t *) event.mData, mWidth * mHeight * 4);
+ rfbMarkRectAsModified(mVNCScreen, 0, 0, mWidth, mHeight);
+ break;
+
+ default:
+ ALOGE("Unhandled event: %d", event.mId);
+ break;
+ }
+}
+
+ClientGoneHookPtr VNCFlinger::onClientGone(rfbClientPtr /* cl */) {
+ ALOGV("onClientGone");
+ sQueue->enqueue(Event(EVENT_CLIENT_GONE));
+ return 0;
+}
+
+enum rfbNewClientAction VNCFlinger::onNewClient(rfbClientPtr cl) {
+ ALOGV("onNewClient");
+ cl->clientGoneHook = (ClientGoneHookPtr) VNCFlinger::onClientGone;
+ sQueue->enqueue(Event(EVENT_CLIENT_CONNECT));
+ return RFB_CLIENT_ACCEPT;
+}
+
+void VNCFlinger::rfbLogger(const char *format, ...) {
+ va_list args;
+ char buf[256];
+
+ va_start(args, format);
+ vsprintf(buf, format, args);
+ ALOGI("%s", buf);
+ va_end(args);
+}
diff --git a/src/VNCFlinger.h b/src/VNCFlinger.h
new file mode 100644
index 0000000..45057b5
--- /dev/null
+++ b/src/VNCFlinger.h
@@ -0,0 +1,58 @@
+#ifndef VNCFLINGER_H
+#define VNCFLINGER_H
+
+#include "EventQueue.h"
+#include "VirtualDisplay.h"
+
+#include <ui/DisplayInfo.h>
+
+#include "rfb/rfb.h"
+
+#define VNC_PORT 5901
+
+namespace android {
+
+class VNCFlinger : public EventListener {
+public:
+ VNCFlinger(int argc, char **argv) :
+ mArgc(argc),
+ mArgv(argv),
+ mClientCount(0) {
+ }
+
+ virtual void onEvent(const Event& event);
+
+ virtual status_t start();
+ virtual status_t stop();
+
+ static EventQueue *sQueue;
+
+private:
+ virtual status_t setup_l();
+ virtual void release_l();
+
+ static ClientGoneHookPtr onClientGone(rfbClientPtr cl);
+ static enum rfbNewClientAction onNewClient(rfbClientPtr cl);
+ static void rfbLogger(const char *format, ...);
+
+ rfbScreenInfoPtr mVNCScreen;
+ uint8_t *mVNCBuf;
+
+ uint32_t mWidth, mHeight;
+ bool mRotate;
+
+ sp<IBinder> mMainDpy;
+ DisplayInfo mMainDpyInfo;
+
+ Mutex mMutex;
+
+ sp<VirtualDisplay> mVirtualDisplay;
+
+ int mArgc;
+ char **mArgv;
+
+ size_t mClientCount;
+};
+
+};
+#endif
diff --git a/src/VirtualDisplay.cpp b/src/VirtualDisplay.cpp
new file mode 100644
index 0000000..369d271
--- /dev/null
+++ b/src/VirtualDisplay.cpp
@@ -0,0 +1,297 @@
+/*
+ * Copyright 2014 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 "VNC-VirtualDisplay"
+//#define LOG_NDEBUG 0
+#include <utils/Log.h>
+
+#include <binder/IPCThreadState.h>
+#include <binder/ProcessState.h>
+
+#include <gui/SurfaceComposerClient.h>
+
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#include <GLES3/gl3.h>
+
+#include <ui/Rect.h>
+
+#include "VirtualDisplay.h"
+
+using namespace android;
+
+static const int kGlBytesPerPixel = 4; // GL_RGBA
+
+
+/*
+ * Returns "true" if the device is rotated 90 degrees.
+ */
+bool VirtualDisplay::isDeviceRotated(int orientation) {
+ return orientation != DISPLAY_ORIENTATION_0 &&
+ orientation != DISPLAY_ORIENTATION_180;
+}
+
+/*
+ * Sets the display projection, based on the display dimensions, video size,
+ * and device orientation.
+ */
+status_t VirtualDisplay::setDisplayProjection(const sp<IBinder>& dpy,
+ const DisplayInfo& mMainDpyInfo) {
+ status_t err;
+
+ // Set the region of the layer stack we're interested in, which in our
+ // case is "all of it". If the app is rotated (so that the width of the
+ // app is based on the height of the display), reverse width/height.
+ bool deviceRotated = isDeviceRotated(mMainDpyInfo.orientation);
+ uint32_t sourceWidth, sourceHeight;
+ if (!deviceRotated) {
+ sourceWidth = mMainDpyInfo.w;
+ sourceHeight = mMainDpyInfo.h;
+ } else {
+ ALOGV("using rotated width/height");
+ sourceHeight = mMainDpyInfo.w;
+ sourceWidth = mMainDpyInfo.h;
+ }
+ Rect layerStackRect(sourceWidth, sourceHeight);
+
+ // We need to preserve the aspect ratio of the display.
+ float displayAspect = (float) sourceHeight / (float) sourceWidth;
+
+
+ // Set the way we map the output onto the display surface (which will
+ // be e.g. 1280x720 for a 720p video). The rect is interpreted
+ // post-rotation, so if the display is rotated 90 degrees we need to
+ // "pre-rotate" it by flipping width/height, so that the orientation
+ // adjustment changes it back.
+ //
+ // We might want to encode a portrait display as landscape to use more
+ // of the screen real estate. (If players respect a 90-degree rotation
+ // hint, we can essentially get a 720x1280 video instead of 1280x720.)
+ // In that case, we swap the configured video width/height and then
+ // supply a rotation value to the display projection.
+ uint32_t videoWidth, videoHeight;
+ uint32_t outWidth, outHeight;
+ if (!mRotate) {
+ videoWidth = mWidth;
+ videoHeight = mHeight;
+ } else {
+ videoWidth = mHeight;
+ videoHeight = mWidth;
+ }
+ if (videoHeight > (uint32_t)(videoWidth * displayAspect)) {
+ // limited by narrow width; reduce height
+ outWidth = videoWidth;
+ outHeight = (uint32_t)(videoWidth * displayAspect);
+ } else {
+ // limited by short height; restrict width
+ outHeight = videoHeight;
+ outWidth = (uint32_t)(videoHeight / displayAspect);
+ }
+ uint32_t offX, offY;
+ offX = (videoWidth - outWidth) / 2;
+ offY = (videoHeight - outHeight) / 2;
+ Rect displayRect(offX, offY, offX + outWidth, offY + outHeight);
+
+ if (mRotate) {
+ printf("Rotated content area is %ux%u at offset x=%d y=%d\n",
+ outHeight, outWidth, offY, offX);
+ } else {
+ printf("Content area is %ux%u at offset x=%d y=%d\n",
+ outWidth, outHeight, offX, offY);
+ }
+
+ SurfaceComposerClient::setDisplayProjection(dpy,
+ mRotate ? DISPLAY_ORIENTATION_90 : DISPLAY_ORIENTATION_0,
+ layerStackRect, displayRect);
+ return NO_ERROR;
+}
+
+status_t VirtualDisplay::start(const DisplayInfo& mainDpyInfo, EventQueue *queue) {
+
+ Mutex::Autolock _l(mMutex);
+
+ mQueue = queue;
+
+ mRotate = isDeviceRotated(mainDpyInfo.orientation);
+ mWidth = mRotate ? mainDpyInfo.h : mainDpyInfo.w;
+ mHeight = mRotate ? mainDpyInfo.w : mainDpyInfo.h;
+
+ sp<ProcessState> self = ProcessState::self();
+ self->startThreadPool();
+
+ run("vnc-virtualdisplay");
+
+ mState = INIT;
+ while (mState == INIT) {
+ mStartCond.wait(mMutex);
+ }
+
+ if (mThreadResult != NO_ERROR) {
+ ALOGE("Failed to start VDS thread: err=%d", mThreadResult);
+ return mThreadResult;
+ }
+ assert(mState == RUNNING);
+
+ mDpy = SurfaceComposerClient::createDisplay(
+ String8("VNCFlinger"), false /*secure*/);
+
+ SurfaceComposerClient::openGlobalTransaction();
+ SurfaceComposerClient::setDisplaySurface(mDpy, mProducer);
+ setDisplayProjection(mDpy, mainDpyInfo);
+ SurfaceComposerClient::setDisplayLayerStack(mDpy, 0); // default stack
+ SurfaceComposerClient::closeGlobalTransaction();
+
+ ALOGV("VirtualDisplay::start successful");
+ return NO_ERROR;
+}
+
+status_t VirtualDisplay::stop() {
+ Mutex::Autolock _l(mMutex);
+ mState = STOPPING;
+ mEventCond.signal();
+ return NO_ERROR;
+}
+
+bool VirtualDisplay::threadLoop() {
+ Mutex::Autolock _l(mMutex);
+
+ mThreadResult = setup_l();
+
+ if (mThreadResult != NO_ERROR) {
+ ALOGW("Aborting VDS thread");
+ mState = STOPPED;
+ release_l();
+ mStartCond.broadcast();
+ return false;
+ }
+
+ ALOGV("VDS thread running");
+ mState = RUNNING;
+ mStartCond.broadcast();
+
+ while (mState == RUNNING) {
+ mEventCond.wait(mMutex);
+ ALOGD("Awake, frame available");
+ void* ptr = processFrame_l();
+ const Event ev(EVENT_BUFFER_READY, ptr);
+ mQueue->enqueue(ev);
+ }
+
+ ALOGV("VDS thread stopping");
+ release_l();
+ mState = STOPPED;
+ return false; // stop
+}
+
+status_t VirtualDisplay::setup_l() {
+ status_t err;
+
+ err = mEglWindow.createPbuffer(mWidth, mHeight);
+ if (err != NO_ERROR) {
+ return err;
+ }
+ mEglWindow.makeCurrent();
+
+ glViewport(0, 0, mWidth, mHeight);
+ glDisable(GL_DEPTH_TEST);
+ glDisable(GL_CULL_FACE);
+
+ // Shader for rendering the external texture.
+ err = mExtTexProgram.setup(Program::PROGRAM_EXTERNAL_TEXTURE);
+ if (err != NO_ERROR) {
+ return err;
+ }
+
+ // Input side (buffers from virtual display).
+ glGenTextures(1, &mExtTextureName);
+ if (mExtTextureName == 0) {
+ ALOGE("glGenTextures failed: %#x", glGetError());
+ return UNKNOWN_ERROR;
+ }
+
+ mBufSize = mWidth * mHeight * kGlBytesPerPixel;
+
+ // pixel buffer for image copy
+ mPBO = new GLuint[NUM_PBO];
+ glGenBuffers(NUM_PBO, mPBO);
+
+ for (unsigned int i = 0; i < NUM_PBO; i++) {
+ glBindBuffer(GL_PIXEL_PACK_BUFFER, mPBO[i]);
+ glBufferData(GL_PIXEL_PACK_BUFFER, mBufSize, 0, GL_DYNAMIC_READ);
+ glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
+ }
+
+ sp<IGraphicBufferConsumer> consumer;
+ BufferQueue::createBufferQueue(&mProducer, &consumer);
+ mGlConsumer = new GLConsumer(consumer, mExtTextureName,
+ GL_TEXTURE_EXTERNAL_OES, true, false);
+ mGlConsumer->setName(String8("virtual display"));
+ mGlConsumer->setDefaultBufferSize(mWidth, mHeight);
+ mProducer->setMaxDequeuedBufferCount(4);
+ mGlConsumer->setConsumerUsageBits(GRALLOC_USAGE_HW_TEXTURE);
+
+ mGlConsumer->setFrameAvailableListener(this);
+
+ ALOGD("VirtualDisplay::setup_l OK");
+ return NO_ERROR;
+}
+
+void* VirtualDisplay::processFrame_l() {
+ ALOGD("processFrame_l\n");
+
+ float texMatrix[16];
+ mGlConsumer->updateTexImage();
+ mGlConsumer->getTransformMatrix(texMatrix);
+
+ // The data is in an external texture, so we need to render it to the
+ // pbuffer to get access to RGB pixel data. We also want to flip it
+ // upside-down for easy conversion to a bitmap.
+ int width = mEglWindow.getWidth();
+ int height = mEglWindow.getHeight();
+ mExtTexProgram.blit(mExtTextureName, texMatrix, 0, 0, mWidth, mHeight, true);
+
+ GLenum glErr;
+ glBindBuffer(GL_PIXEL_PACK_BUFFER, mPBO[mIndex]);
+ glReadPixels(0, 0, mWidth, mHeight, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+ if ((glErr = glGetError()) != GL_NO_ERROR) {
+ ALOGE("glReadPixels failed: %#x", glErr);
+ return NULL;
+ }
+
+ glBindBuffer(GL_PIXEL_PACK_BUFFER, mPBO[mIndex]);
+ void* ptr = glMapBufferRange(GL_PIXEL_PACK_BUFFER, 0, mBufSize, GL_MAP_READ_BIT);
+ glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
+ glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
+
+ mIndex = (mIndex + 1) % NUM_PBO;
+ return ptr;
+}
+
+void VirtualDisplay::release_l() {
+ ALOGD("release_l");
+ mGlConsumer.clear();
+ mProducer.clear();
+ mExtTexProgram.release();
+ mEglWindow.release();
+ SurfaceComposerClient::destroyDisplay(mDpy);
+}
+
+// Callback; executes on arbitrary thread.
+void VirtualDisplay::onFrameAvailable(const BufferItem& item) {
+ Mutex::Autolock _l(mMutex);
+ mEventCond.signal();
+ ALOGD("mTimestamp=%ld mFrameNumber=%ld", item.mTimestamp, item.mFrameNumber);
+}
diff --git a/src/VirtualDisplay.h b/src/VirtualDisplay.h
new file mode 100644
index 0000000..ccfb718
--- /dev/null
+++ b/src/VirtualDisplay.h
@@ -0,0 +1,130 @@
+/*
+ * Copyright 2014 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 VDS_H
+#define VDS_H
+
+#include "EventQueue.h"
+#include "Program.h"
+#include "EglWindow.h"
+
+#include <gui/BufferQueue.h>
+#include <gui/GLConsumer.h>
+#include <gui/IGraphicBufferProducer.h>
+#include <ui/DisplayInfo.h>
+#include <utils/Thread.h>
+
+
+#define NUM_PBO 2
+
+namespace android {
+
+/*
+ * Support for "frames" output format.
+ */
+class VirtualDisplay : public GLConsumer::FrameAvailableListener, Thread {
+public:
+ VirtualDisplay() : Thread(false),
+ mThreadResult(UNKNOWN_ERROR),
+ mState(UNINITIALIZED),
+ mIndex(0)
+ {}
+
+ // Create an "input surface", similar in purpose to a MediaCodec input
+ // surface, that the virtual display can send buffers to. Also configures
+ // EGL with a pbuffer surface on the current thread.
+ status_t start(const DisplayInfo& mainDpyInfo, EventQueue *queue);
+
+ status_t stop();
+
+ static bool isDeviceRotated(int orientation);
+
+private:
+ VirtualDisplay(const VirtualDisplay&);
+ VirtualDisplay& operator=(const VirtualDisplay&);
+
+ // Destruction via RefBase.
+ virtual ~VirtualDisplay() {
+ assert(mState == UNINITIALIZED || mState == STOPPED);
+ }
+
+ virtual status_t setDisplayProjection(const sp<IBinder>& dpy,
+ const DisplayInfo& mainDpyInfo);
+
+ // (overrides GLConsumer::FrameAvailableListener method)
+ virtual void onFrameAvailable(const BufferItem& item);
+
+ // (overrides Thread method)
+ virtual bool threadLoop();
+
+ // One-time setup (essentially object construction on the overlay thread).
+ status_t setup_l();
+
+ // Release all resources held.
+ void release_l();
+
+ // Process a frame received from the virtual display.
+ void* processFrame_l();
+
+ uint32_t mHeight, mWidth;
+ bool mRotate;
+
+ EventQueue *mQueue;
+
+ // Used to wait for the FrameAvailableListener callback.
+ Mutex mMutex;
+
+ // Initialization gate.
+ Condition mStartCond;
+
+ // Thread status, mostly useful during startup.
+ status_t mThreadResult;
+ // Overlay thread state. States advance from left to right; object may
+ // not be restarted.
+ enum { UNINITIALIZED, INIT, RUNNING, STOPPING, STOPPED } mState;
+
+ // Event notification. Overlay thread sleeps on this until a frame
+ // arrives or it's time to shut down.
+ Condition mEventCond;
+
+ // Producer side of queue, passed into the virtual display.
+ // The consumer end feeds into our GLConsumer.
+ sp<IGraphicBufferProducer> mProducer;
+
+ // This receives frames from the virtual display and makes them available
+ // as an external texture.
+ sp<GLConsumer> mGlConsumer;
+
+ // EGL display / context / surface.
+ EglWindow mEglWindow;
+
+ // GL rendering support.
+ Program mExtTexProgram;
+
+ // External texture, updated by GLConsumer.
+ GLuint mExtTextureName;
+
+ // Pixel data buffers.
+ size_t mBufSize;
+ GLuint* mPBO;
+ unsigned int mIndex;
+
+ sp<IBinder> mDpy;
+};
+
+}; // namespace android
+
+#endif /* VDS_H */
diff --git a/src/main.cpp b/src/main.cpp
new file mode 100644
index 0000000..0223f78
--- /dev/null
+++ b/src/main.cpp
@@ -0,0 +1,8 @@
+#include "VNCFlinger.h"
+
+using namespace android;
+
+int main(int argc, char **argv) {
+ VNCFlinger flinger(argc, argv);
+ flinger.start();
+}