src/AndroidDesktop.cpp - android_external_vncflinger - Gitiles

 #define LOG_TAG "AndroidDesktop"
 #include <utils/Log.h>

 #include <fcntl.h>
 #include <sys/eventfd.h>

 #include <binder/IPCThreadState.h>
 #include <binder/IServiceManager.h>
 #include <binder/ProcessState.h>

 #include <gui/ISurfaceComposer.h>
 #include <gui/SurfaceComposerClient.h>

 #include <ui/DisplayInfo.h>

 #include <rfb/PixelFormat.h>
 #include <rfb/Rect.h>
 #include <rfb/ScreenSet.h>
 #include <rfb/VNCServerST.h>

 #include "AndroidDesktop.h"
 #include "InputDevice.h"

 using namespace vncflinger;
 using namespace android;

 const rfb::PixelFormat AndroidDesktop::sRGBX(32, 24, false, true, 255, 255, 255, 0, 8, 16);

 AndroidDesktop::AndroidDesktop() {
     mListener = new FrameListener(this);
     mInputDevice = new InputDevice();

     mEventFd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
     if (mEventFd < 0) {
         ALOGE("Failed to create event notifier");
         return;
     }
 }

 AndroidDesktop::~AndroidDesktop() {
     mInputDevice->stop();
     close(mEventFd);
 }

 void AndroidDesktop::start(rfb::VNCServer* vs) {
     Mutex::Autolock _l(mMutex);

     sp<ProcessState> self = ProcessState::self();
     self->startThreadPool();

     mMainDpy = SurfaceComposerClient::getBuiltInDisplay(ISurfaceComposer::eDisplayIdMain);
     if (updateDisplayProjection() == NO_INIT) {
         ALOGE("Failed to query display!");
         return;
     }
     mProjectionChanged = false;

     status_t err = createVirtualDisplay();
     if (err != NO_ERROR) {
         ALOGE("Failed to create virtual display: err=%d", err);
         return;
     }

     mInputDevice->start_async(mWidth, mHeight);

     mServer = (rfb::VNCServerST*)vs;

     updateFBSize(mWidth, mHeight);

     mServer->setPixelBuffer(mPixels.get());

     ALOGV("Desktop is running");
 }

 void AndroidDesktop::stop() {
     Mutex::Autolock _L(mMutex);

     ALOGV("Shutting down");

     mServer->setPixelBuffer(0);
     destroyVirtualDisplay();
     mWidth = 0;
     mHeight = 0;
 }

 status_t AndroidDesktop::createVirtualDisplay() {
     sp<IGraphicBufferConsumer> consumer;
     BufferQueue::createBufferQueue(&mProducer, &consumer);
     mCpuConsumer = new CpuConsumer(consumer, 1);
     mCpuConsumer->setName(String8("vds-to-cpu"));
     mCpuConsumer->setDefaultBufferSize(mWidth, mHeight);
     mProducer->setMaxDequeuedBufferCount(4);
     consumer->setDefaultBufferFormat(PIXEL_FORMAT_RGBX_8888);

     mCpuConsumer->setFrameAvailableListener(mListener);

     mDpy = SurfaceComposerClient::createDisplay(String8("VNC-VirtualDisplay"), false /*secure*/);

     // aspect ratio
     float displayAspect = (float) mSourceHeight / (float) mSourceWidth;

     uint32_t outWidth, outHeight;
     if (mWidth > (uint32_t)(mWidth * displayAspect)) {
         // limited by narrow width; reduce height
         outWidth = mWidth;
         outHeight = (uint32_t)(mWidth * displayAspect);
     } else {
         // limited by short height; restrict width
         outHeight = mHeight;
         outWidth = (uint32_t)(mHeight / displayAspect);
     }

     // position the desktop in the viewport while preserving
     // the source aspect ratio. we do this in case the client
     // has resized the window and to deal with orientation
     // changes set up by updateDisplayProjection
     uint32_t offX, offY;
     offX = (mWidth - outWidth) / 2;
     offY = (mHeight - outHeight) / 2;
     mDisplayRect = Rect(offX, offY, offX + outWidth, offY + outHeight);
     Rect sourceRect(0, 0, mSourceWidth, mSourceHeight);

     SurfaceComposerClient::openGlobalTransaction();
     SurfaceComposerClient::setDisplaySurface(mDpy, mProducer);
     SurfaceComposerClient::setDisplayProjection(mDpy, 0, sourceRect, mDisplayRect);
     SurfaceComposerClient::setDisplayLayerStack(mDpy, 0);  // default stack
     SurfaceComposerClient::closeGlobalTransaction();

     mVDSActive = true;

     ALOGV("Virtual display (%lux%lu [viewport=%ux%u] created", mWidth, mHeight,
             outWidth, outHeight);

     return NO_ERROR;
 }

 status_t AndroidDesktop::destroyVirtualDisplay() {
     if (!mVDSActive) {
         return NO_INIT;
     }

     mCpuConsumer.clear();
     mProducer.clear();
     SurfaceComposerClient::destroyDisplay(mDpy);

     mVDSActive = false;

     ALOGV("Virtual display destroyed");

     return NO_ERROR;
 }

 void AndroidDesktop::processDesktopResize() {
     if (mProjectionChanged) {
         destroyVirtualDisplay();
         createVirtualDisplay();
         updateFBSize(mWidth, mHeight);
         mInputDevice->reconfigure(mDisplayRect.getWidth(), mDisplayRect.getHeight());
         rfb::ScreenSet screens;
         screens.add_screen(rfb::Screen(0, 0, 0, mWidth, mHeight, 0));
         mServer->setScreenLayout(screens);

         mProjectionChanged = false;
     }
 }

 void AndroidDesktop::processFrames() {
     Mutex::Autolock _l(mMutex);

     // do any pending resize
     processDesktopResize();

     if (!mFrameAvailable) {
         return;
     }

     // get a frame from the virtual display
     CpuConsumer::LockedBuffer imgBuffer;
     status_t res = mCpuConsumer->lockNextBuffer(&imgBuffer);
     if (res != OK) {
         ALOGE("Failed to lock next buffer: %s (%d)", strerror(-res), res);
         return;
     }

     mFrameNumber = imgBuffer.frameNumber;
     ALOGV("processFrame: [%lu] format: %x (%dx%d, stride=%d)", mFrameNumber, imgBuffer.format,
           imgBuffer.width, imgBuffer.height, imgBuffer.stride);

     // we don't know if there was a stride change until we get
     // a buffer from the queue. if it changed, we need to resize

     rfb::Rect bufRect(0, 0, imgBuffer.width, imgBuffer.height);

     // performance is extremely bad if the gpu memory is used
     // directly without copying because it is likely uncached
     mPixels->imageRect(bufRect, imgBuffer.data, imgBuffer.stride);

     mCpuConsumer->unlockBuffer(imgBuffer);

     // update clients
     mServer->add_changed(bufRect);
     mFrameAvailable = false;
 }

 // notifies the server loop that we have changes
 void AndroidDesktop::notify() {
     static uint64_t notify = 1;
     write(mEventFd, &notify, sizeof(notify));
 }

 // called when a client resizes the window
 unsigned int AndroidDesktop::setScreenLayout(int reqWidth, int reqHeight,
                                              const rfb::ScreenSet& layout) {
     Mutex::Autolock _l(mMutex);

     char* dbg = new char[1024];
     layout.print(dbg, 1024);

     ALOGD("setScreenLayout: cur: %lux%lu  new: %dx%d %s", mWidth, mHeight, reqWidth, reqHeight, dbg);
     delete[] dbg;

     if (reqWidth == (int)mWidth && reqHeight == (int)mHeight) {
         return rfb::resultInvalid;
     }

     if (reqWidth > 0 && reqHeight > 0) {
         mWidth = reqWidth;
         mHeight = reqHeight;

         if (updateDisplayProjection() == NO_ERROR) {
             // resize immediately
             processDesktopResize();
             notify();
             return rfb::resultSuccess;
         }
     }
     return rfb::resultInvalid;
 }

 // updates the pixelbuffer dimensions
 bool AndroidDesktop::updateFBSize(uint64_t width, uint64_t height) {
     if (mPixels == nullptr || mPixels->height() != (int)height || mPixels->width() != (int)width) {
         if (mPixels != nullptr) {
             ALOGD("updateFBSize: old=[%dx%d] new=[%lux%lu]", mPixels->width(), mPixels->height(),
                   width, height);
         }
         if (mPixels != nullptr && (int)width <= mPixels->width() &&
             (int)height <= mPixels->height()) {
             mPixels->setSize(width, height);
         } else {
             mPixels = new AndroidPixelBuffer(width, height);
             mServer->setPixelBuffer(mPixels.get());
         }
         return true;
     }
     return false;
 }

 // cpuconsumer frame listener, called from binder thread
 void AndroidDesktop::FrameListener::onFrameAvailable(const BufferItem& item) {
     Mutex::Autolock _l(mDesktop->mMutex);
     mDesktop->updateDisplayProjection();
     mDesktop->mFrameAvailable = true;
     mDesktop->notify();
     ALOGV("onFrameAvailable: [%lu] mTimestamp=%ld", item.mFrameNumber, item.mTimestamp);
 }

 rfb::Point AndroidDesktop::getFbSize() {
     return rfb::Point(mPixels->width(), mPixels->height());
 }

 void AndroidDesktop::keyEvent(rdr::U32 key, bool down) {
     mInputDevice->keyEvent(down, key);
 }

 void AndroidDesktop::pointerEvent(const rfb::Point& pos, int buttonMask) {
     if (pos.x < mDisplayRect.left || pos.x > mDisplayRect.right ||
             pos.y < mDisplayRect.top || pos.y > mDisplayRect.bottom) {
         // outside viewport
         return;
     }
     uint32_t x = pos.x * ((float)(mDisplayRect.getWidth()) / (float)mWidth);
     uint32_t y = pos.y * ((float)(mDisplayRect.getHeight()) / (float)mHeight);

     ALOGD("pointer xlate x1=%d y1=%d x2=%d y2=%d", pos.x, pos.y, x, y);

     mServer->setCursorPos(rfb::Point(x, y));
     mInputDevice->pointerEvent(buttonMask, x, y);
 }

 // figure out the dimensions of the display. deal with orientation
 // changes, client-side window resize, server-side scaling, and
 // maintaining aspect ratio.
 status_t AndroidDesktop::updateDisplayProjection() {
     DisplayInfo info;
     status_t err = SurfaceComposerClient::getDisplayInfo(mMainDpy, &info);
     if (err != NO_ERROR) {
         ALOGE("Failed to get display characteristics\n");
         return err;
     }

     bool deviceRotated =
         info.orientation != DISPLAY_ORIENTATION_0 && info.orientation != DISPLAY_ORIENTATION_180;

     // if orientation changed, swap width/height
     uint32_t sourceWidth, sourceHeight;
     if (!deviceRotated) {
         sourceWidth = info.w;
         sourceHeight = info.h;
     } else {
         sourceHeight = info.w;
         sourceWidth = info.h;
     }

     if (mWidth == 0 && mHeight == 0) {
         mWidth = sourceWidth;
         mHeight = sourceHeight;
     }

     if (deviceRotated != mRotated) {
         std::swap(mWidth, mHeight);
         mRotated = deviceRotated;
     }

     // if nothing changed, we're done
     if (mSourceWidth == sourceWidth && mSourceHeight == sourceHeight &&
         (int)mWidth == mPixels->width() && (int)mHeight == mPixels->height()) {
         return NO_ERROR;
     }

     // update all the values and flag for an update
     mSourceWidth = sourceWidth;
     mSourceHeight = sourceHeight;
     mProjectionChanged = true;

     ALOGV("Dimensions: %lux%lu [out: %lux%lu] rotated=%d", mSourceWidth, mSourceHeight, mWidth,
           mHeight, mRotated);

     return NO_ERROR;
 }
	#define LOG_TAG "AndroidDesktop"
	#include <utils/Log.h>

	#include <fcntl.h>
	#include <sys/eventfd.h>

	#include <binder/IPCThreadState.h>
	#include <binder/IServiceManager.h>
	#include <binder/ProcessState.h>

	#include <gui/ISurfaceComposer.h>
	#include <gui/SurfaceComposerClient.h>

	#include <ui/DisplayInfo.h>

	#include <rfb/PixelFormat.h>
	#include <rfb/Rect.h>
	#include <rfb/ScreenSet.h>
	#include <rfb/VNCServerST.h>

	#include "AndroidDesktop.h"
	#include "InputDevice.h"

	using namespace vncflinger;
	using namespace android;

	const rfb::PixelFormat AndroidDesktop::sRGBX(32, 24, false, true, 255, 255, 255, 0, 8, 16);

	AndroidDesktop::AndroidDesktop() {
	mListener = new FrameListener(this);
	mInputDevice = new InputDevice();

	mEventFd = eventfd(0, EFD_CLOEXEC \| EFD_NONBLOCK);
	if (mEventFd < 0) {
	ALOGE("Failed to create event notifier");
	return;
	}
	}

	AndroidDesktop::~AndroidDesktop() {
	mInputDevice->stop();
	close(mEventFd);
	}

	void AndroidDesktop::start(rfb::VNCServer* vs) {
	Mutex::Autolock _l(mMutex);

	sp<ProcessState> self = ProcessState::self();
	self->startThreadPool();

	mMainDpy = SurfaceComposerClient::getBuiltInDisplay(ISurfaceComposer::eDisplayIdMain);
	if (updateDisplayProjection() == NO_INIT) {
	ALOGE("Failed to query display!");
	return;
	}
	mProjectionChanged = false;

	status_t err = createVirtualDisplay();
	if (err != NO_ERROR) {
	ALOGE("Failed to create virtual display: err=%d", err);
	return;
	}

	mInputDevice->start_async(mWidth, mHeight);

	mServer = (rfb::VNCServerST*)vs;

	updateFBSize(mWidth, mHeight);

	mServer->setPixelBuffer(mPixels.get());

	ALOGV("Desktop is running");
	}

	void AndroidDesktop::stop() {
	Mutex::Autolock _L(mMutex);

	ALOGV("Shutting down");

	mServer->setPixelBuffer(0);
	destroyVirtualDisplay();
	mWidth = 0;
	mHeight = 0;
	}

	status_t AndroidDesktop::createVirtualDisplay() {
	sp<IGraphicBufferConsumer> consumer;
	BufferQueue::createBufferQueue(&mProducer, &consumer);
	mCpuConsumer = new CpuConsumer(consumer, 1);
	mCpuConsumer->setName(String8("vds-to-cpu"));
	mCpuConsumer->setDefaultBufferSize(mWidth, mHeight);
	mProducer->setMaxDequeuedBufferCount(4);
	consumer->setDefaultBufferFormat(PIXEL_FORMAT_RGBX_8888);

	mCpuConsumer->setFrameAvailableListener(mListener);

	mDpy = SurfaceComposerClient::createDisplay(String8("VNC-VirtualDisplay"), false /secure/);

	// aspect ratio
	float displayAspect = (float) mSourceHeight / (float) mSourceWidth;

	uint32_t outWidth, outHeight;
	if (mWidth > (uint32_t)(mWidth * displayAspect)) {
	// limited by narrow width; reduce height
	outWidth = mWidth;
	outHeight = (uint32_t)(mWidth * displayAspect);
	} else {
	// limited by short height; restrict width
	outHeight = mHeight;
	outWidth = (uint32_t)(mHeight / displayAspect);
	}

	// position the desktop in the viewport while preserving
	// the source aspect ratio. we do this in case the client
	// has resized the window and to deal with orientation
	// changes set up by updateDisplayProjection
	uint32_t offX, offY;
	offX = (mWidth - outWidth) / 2;
	offY = (mHeight - outHeight) / 2;
	mDisplayRect = Rect(offX, offY, offX + outWidth, offY + outHeight);
	Rect sourceRect(0, 0, mSourceWidth, mSourceHeight);

	SurfaceComposerClient::openGlobalTransaction();
	SurfaceComposerClient::setDisplaySurface(mDpy, mProducer);
	SurfaceComposerClient::setDisplayProjection(mDpy, 0, sourceRect, mDisplayRect);
	SurfaceComposerClient::setDisplayLayerStack(mDpy, 0); // default stack
	SurfaceComposerClient::closeGlobalTransaction();

	mVDSActive = true;

	ALOGV("Virtual display (%lux%lu [viewport=%ux%u] created", mWidth, mHeight,
	outWidth, outHeight);

	return NO_ERROR;
	}

	status_t AndroidDesktop::destroyVirtualDisplay() {
	if (!mVDSActive) {
	return NO_INIT;
	}

	mCpuConsumer.clear();
	mProducer.clear();
	SurfaceComposerClient::destroyDisplay(mDpy);

	mVDSActive = false;

	ALOGV("Virtual display destroyed");

	return NO_ERROR;
	}

	void AndroidDesktop::processDesktopResize() {
	if (mProjectionChanged) {
	destroyVirtualDisplay();
	createVirtualDisplay();
	updateFBSize(mWidth, mHeight);
	mInputDevice->reconfigure(mDisplayRect.getWidth(), mDisplayRect.getHeight());
	rfb::ScreenSet screens;
	screens.add_screen(rfb::Screen(0, 0, 0, mWidth, mHeight, 0));
	mServer->setScreenLayout(screens);

	mProjectionChanged = false;
	}
	}

	void AndroidDesktop::processFrames() {
	Mutex::Autolock _l(mMutex);

	// do any pending resize
	processDesktopResize();

	if (!mFrameAvailable) {
	return;
	}

	// get a frame from the virtual display
	CpuConsumer::LockedBuffer imgBuffer;
	status_t res = mCpuConsumer->lockNextBuffer(&imgBuffer);
	if (res != OK) {
	ALOGE("Failed to lock next buffer: %s (%d)", strerror(-res), res);
	return;
	}

	mFrameNumber = imgBuffer.frameNumber;
	ALOGV("processFrame: [%lu] format: %x (%dx%d, stride=%d)", mFrameNumber, imgBuffer.format,
	imgBuffer.width, imgBuffer.height, imgBuffer.stride);

	// we don't know if there was a stride change until we get
	// a buffer from the queue. if it changed, we need to resize

	rfb::Rect bufRect(0, 0, imgBuffer.width, imgBuffer.height);

	// performance is extremely bad if the gpu memory is used
	// directly without copying because it is likely uncached
	mPixels->imageRect(bufRect, imgBuffer.data, imgBuffer.stride);

	mCpuConsumer->unlockBuffer(imgBuffer);

	// update clients
	mServer->add_changed(bufRect);
	mFrameAvailable = false;
	}

	// notifies the server loop that we have changes
	void AndroidDesktop::notify() {
	static uint64_t notify = 1;
	write(mEventFd, &notify, sizeof(notify));
	}

	// called when a client resizes the window
	unsigned int AndroidDesktop::setScreenLayout(int reqWidth, int reqHeight,
	const rfb::ScreenSet& layout) {
	Mutex::Autolock _l(mMutex);

	char* dbg = new char[1024];
	layout.print(dbg, 1024);

	ALOGD("setScreenLayout: cur: %lux%lu new: %dx%d %s", mWidth, mHeight, reqWidth, reqHeight, dbg);
	delete[] dbg;

	if (reqWidth == (int)mWidth && reqHeight == (int)mHeight) {
	return rfb::resultInvalid;
	}

	if (reqWidth > 0 && reqHeight > 0) {
	mWidth = reqWidth;
	mHeight = reqHeight;

	if (updateDisplayProjection() == NO_ERROR) {
	// resize immediately
	processDesktopResize();
	notify();
	return rfb::resultSuccess;
	}
	}
	return rfb::resultInvalid;
	}

	// updates the pixelbuffer dimensions
	bool AndroidDesktop::updateFBSize(uint64_t width, uint64_t height) {
	if (mPixels == nullptr \|\| mPixels->height() != (int)height \|\| mPixels->width() != (int)width) {
	if (mPixels != nullptr) {
	ALOGD("updateFBSize: old=[%dx%d] new=[%lux%lu]", mPixels->width(), mPixels->height(),
	width, height);
	}
	if (mPixels != nullptr && (int)width <= mPixels->width() &&
	(int)height <= mPixels->height()) {
	mPixels->setSize(width, height);
	} else {
	mPixels = new AndroidPixelBuffer(width, height);
	mServer->setPixelBuffer(mPixels.get());
	}
	return true;
	}
	return false;
	}

	// cpuconsumer frame listener, called from binder thread
	void AndroidDesktop::FrameListener::onFrameAvailable(const BufferItem& item) {
	Mutex::Autolock _l(mDesktop->mMutex);
	mDesktop->updateDisplayProjection();
	mDesktop->mFrameAvailable = true;
	mDesktop->notify();
	ALOGV("onFrameAvailable: [%lu] mTimestamp=%ld", item.mFrameNumber, item.mTimestamp);
	}

	rfb::Point AndroidDesktop::getFbSize() {
	return rfb::Point(mPixels->width(), mPixels->height());
	}

	void AndroidDesktop::keyEvent(rdr::U32 key, bool down) {
	mInputDevice->keyEvent(down, key);
	}

	void AndroidDesktop::pointerEvent(const rfb::Point& pos, int buttonMask) {
	if (pos.x < mDisplayRect.left \|\| pos.x > mDisplayRect.right \|\|
	pos.y < mDisplayRect.top \|\| pos.y > mDisplayRect.bottom) {
	// outside viewport
	return;
	}
	uint32_t x = pos.x * ((float)(mDisplayRect.getWidth()) / (float)mWidth);
	uint32_t y = pos.y * ((float)(mDisplayRect.getHeight()) / (float)mHeight);

	ALOGD("pointer xlate x1=%d y1=%d x2=%d y2=%d", pos.x, pos.y, x, y);

	mServer->setCursorPos(rfb::Point(x, y));
	mInputDevice->pointerEvent(buttonMask, x, y);
	}

	// figure out the dimensions of the display. deal with orientation
	// changes, client-side window resize, server-side scaling, and
	// maintaining aspect ratio.
	status_t AndroidDesktop::updateDisplayProjection() {
	DisplayInfo info;
	status_t err = SurfaceComposerClient::getDisplayInfo(mMainDpy, &info);
	if (err != NO_ERROR) {
	ALOGE("Failed to get display characteristics\n");
	return err;
	}

	bool deviceRotated =
	info.orientation != DISPLAY_ORIENTATION_0 && info.orientation != DISPLAY_ORIENTATION_180;

	// if orientation changed, swap width/height
	uint32_t sourceWidth, sourceHeight;
	if (!deviceRotated) {
	sourceWidth = info.w;
	sourceHeight = info.h;
	} else {
	sourceHeight = info.w;
	sourceWidth = info.h;
	}

	if (mWidth == 0 && mHeight == 0) {
	mWidth = sourceWidth;
	mHeight = sourceHeight;
	}

	if (deviceRotated != mRotated) {
	std::swap(mWidth, mHeight);
	mRotated = deviceRotated;
	}

	// if nothing changed, we're done
	if (mSourceWidth == sourceWidth && mSourceHeight == sourceHeight &&
	(int)mWidth == mPixels->width() && (int)mHeight == mPixels->height()) {
	return NO_ERROR;
	}

	// update all the values and flag for an update
	mSourceWidth = sourceWidth;
	mSourceHeight = sourceHeight;
	mProjectionChanged = true;

	ALOGV("Dimensions: %lux%lu [out: %lux%lu] rotated=%d", mSourceWidth, mSourceHeight, mWidth,
	mHeight, mRotated);

	return NO_ERROR;
	}