2 * Copyright (C) 2010 The Android Open Source Project
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 #define LOG_TAG "SurfaceTextureClient"
18 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
19 //#define LOG_NDEBUG 0
21 #include <utils/Log.h>
22 #include <utils/Trace.h>
24 #include <gui/ISurfaceComposer.h>
25 #include <gui/SurfaceComposerClient.h>
26 #include <gui/SurfaceTextureClient.h>
28 #include <private/gui/ComposerService.h>
32 SurfaceTextureClient::SurfaceTextureClient(
33 const sp<ISurfaceTexture>& surfaceTexture)
35 SurfaceTextureClient::init();
36 SurfaceTextureClient::setISurfaceTexture(surfaceTexture);
39 SurfaceTextureClient::SurfaceTextureClient() {
40 SurfaceTextureClient::init();
43 SurfaceTextureClient::~SurfaceTextureClient() {
44 if (mConnectedToCpu) {
45 SurfaceTextureClient::disconnect(NATIVE_WINDOW_API_CPU);
49 void SurfaceTextureClient::init() {
50 // Initialize the ANativeWindow function pointers.
51 ANativeWindow::setSwapInterval = hook_setSwapInterval;
52 ANativeWindow::dequeueBuffer = hook_dequeueBuffer;
53 ANativeWindow::cancelBuffer = hook_cancelBuffer;
54 ANativeWindow::lockBuffer = hook_lockBuffer;
55 ANativeWindow::queueBuffer = hook_queueBuffer;
56 ANativeWindow::query = hook_query;
57 ANativeWindow::perform = hook_perform;
59 const_cast<int&>(ANativeWindow::minSwapInterval) = 0;
60 const_cast<int&>(ANativeWindow::maxSwapInterval) = 1;
66 mTimestamp = NATIVE_WINDOW_TIMESTAMP_AUTO;
70 mConnectedToCpu = false;
73 void SurfaceTextureClient::setISurfaceTexture(
74 const sp<ISurfaceTexture>& surfaceTexture)
76 mSurfaceTexture = surfaceTexture;
79 sp<ISurfaceTexture> SurfaceTextureClient::getISurfaceTexture() const {
80 return mSurfaceTexture;
83 int SurfaceTextureClient::hook_setSwapInterval(ANativeWindow* window, int interval) {
84 SurfaceTextureClient* c = getSelf(window);
85 return c->setSwapInterval(interval);
88 int SurfaceTextureClient::hook_dequeueBuffer(ANativeWindow* window,
89 ANativeWindowBuffer** buffer) {
90 SurfaceTextureClient* c = getSelf(window);
91 return c->dequeueBuffer(buffer);
94 int SurfaceTextureClient::hook_cancelBuffer(ANativeWindow* window,
95 ANativeWindowBuffer* buffer) {
96 SurfaceTextureClient* c = getSelf(window);
97 return c->cancelBuffer(buffer);
100 int SurfaceTextureClient::hook_lockBuffer(ANativeWindow* window,
101 ANativeWindowBuffer* buffer) {
102 SurfaceTextureClient* c = getSelf(window);
103 return c->lockBuffer(buffer);
106 int SurfaceTextureClient::hook_queueBuffer(ANativeWindow* window,
107 ANativeWindowBuffer* buffer) {
108 SurfaceTextureClient* c = getSelf(window);
109 return c->queueBuffer(buffer);
112 int SurfaceTextureClient::hook_query(const ANativeWindow* window,
113 int what, int* value) {
114 const SurfaceTextureClient* c = getSelf(window);
115 return c->query(what, value);
118 int SurfaceTextureClient::hook_perform(ANativeWindow* window, int operation, ...) {
120 va_start(args, operation);
121 SurfaceTextureClient* c = getSelf(window);
122 return c->perform(operation, args);
125 int SurfaceTextureClient::setSwapInterval(int interval) {
127 // EGL specification states:
128 // interval is silently clamped to minimum and maximum implementation
129 // dependent values before being stored.
130 // Although we don't have to, we apply the same logic here.
132 if (interval < minSwapInterval)
133 interval = minSwapInterval;
135 if (interval > maxSwapInterval)
136 interval = maxSwapInterval;
138 status_t res = mSurfaceTexture->setSynchronousMode(interval ? true : false);
143 int SurfaceTextureClient::dequeueBuffer(android_native_buffer_t** buffer) {
145 ALOGV("SurfaceTextureClient::dequeueBuffer");
146 Mutex::Autolock lock(mMutex);
148 status_t result = mSurfaceTexture->dequeueBuffer(&buf, mReqWidth, mReqHeight,
149 mReqFormat, mReqUsage);
151 ALOGV("dequeueBuffer: ISurfaceTexture::dequeueBuffer(%d, %d, %d, %d)"
152 "failed: %d", mReqWidth, mReqHeight, mReqFormat, mReqUsage,
156 sp<GraphicBuffer>& gbuf(mSlots[buf]);
157 if (result & ISurfaceTexture::RELEASE_ALL_BUFFERS) {
161 if ((result & ISurfaceTexture::BUFFER_NEEDS_REALLOCATION) || gbuf == 0) {
162 result = mSurfaceTexture->requestBuffer(buf, &gbuf);
163 if (result != NO_ERROR) {
164 ALOGE("dequeueBuffer: ISurfaceTexture::requestBuffer failed: %d",
169 *buffer = gbuf.get();
173 int SurfaceTextureClient::cancelBuffer(android_native_buffer_t* buffer) {
175 ALOGV("SurfaceTextureClient::cancelBuffer");
176 Mutex::Autolock lock(mMutex);
177 int i = getSlotFromBufferLocked(buffer);
181 mSurfaceTexture->cancelBuffer(i);
185 int SurfaceTextureClient::getSlotFromBufferLocked(
186 android_native_buffer_t* buffer) const {
187 bool dumpedState = false;
188 for (int i = 0; i < NUM_BUFFER_SLOTS; i++) {
189 // XXX: Dump the slots whenever we hit a NULL entry while searching for
191 if (mSlots[i] == NULL) {
193 ALOGD("getSlotFromBufferLocked: encountered NULL buffer in slot %d "
194 "looking for buffer %p", i, buffer->handle);
195 for (int j = 0; j < NUM_BUFFER_SLOTS; j++) {
196 if (mSlots[j] == NULL) {
197 ALOGD("getSlotFromBufferLocked: %02d: NULL", j);
199 ALOGD("getSlotFromBufferLocked: %02d: %p", j, mSlots[j]->handle);
206 if (mSlots[i] != NULL && mSlots[i]->handle == buffer->handle) {
210 ALOGE("getSlotFromBufferLocked: unknown buffer: %p", buffer->handle);
214 int SurfaceTextureClient::lockBuffer(android_native_buffer_t* buffer) {
215 ALOGV("SurfaceTextureClient::lockBuffer");
216 Mutex::Autolock lock(mMutex);
220 int SurfaceTextureClient::queueBuffer(android_native_buffer_t* buffer) {
222 ALOGV("SurfaceTextureClient::queueBuffer");
223 Mutex::Autolock lock(mMutex);
225 if (mTimestamp == NATIVE_WINDOW_TIMESTAMP_AUTO) {
226 timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
227 ALOGV("SurfaceTextureClient::queueBuffer making up timestamp: %.2f ms",
228 timestamp / 1000000.f);
230 timestamp = mTimestamp;
232 int i = getSlotFromBufferLocked(buffer);
236 status_t err = mSurfaceTexture->queueBuffer(i, timestamp,
237 &mDefaultWidth, &mDefaultHeight, &mTransformHint);
239 ALOGE("queueBuffer: error queuing buffer to SurfaceTexture, %d", err);
244 int SurfaceTextureClient::query(int what, int* value) const {
246 ALOGV("SurfaceTextureClient::query");
247 { // scope for the lock
248 Mutex::Autolock lock(mMutex);
250 case NATIVE_WINDOW_FORMAT:
256 case NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER:
258 sp<ISurfaceComposer> composer(
259 ComposerService::getComposerService());
260 if (composer->authenticateSurfaceTexture(mSurfaceTexture)) {
267 case NATIVE_WINDOW_CONCRETE_TYPE:
268 *value = NATIVE_WINDOW_SURFACE_TEXTURE_CLIENT;
270 case NATIVE_WINDOW_DEFAULT_WIDTH:
271 *value = mDefaultWidth;
273 case NATIVE_WINDOW_DEFAULT_HEIGHT:
274 *value = mDefaultHeight;
276 case NATIVE_WINDOW_TRANSFORM_HINT:
277 *value = mTransformHint;
281 return mSurfaceTexture->query(what, value);
284 int SurfaceTextureClient::perform(int operation, va_list args)
288 case NATIVE_WINDOW_CONNECT:
289 // deprecated. must return NO_ERROR.
291 case NATIVE_WINDOW_DISCONNECT:
292 // deprecated. must return NO_ERROR.
294 case NATIVE_WINDOW_SET_USAGE:
295 res = dispatchSetUsage(args);
297 case NATIVE_WINDOW_SET_CROP:
298 res = dispatchSetCrop(args);
300 case NATIVE_WINDOW_SET_BUFFER_COUNT:
301 res = dispatchSetBufferCount(args);
303 case NATIVE_WINDOW_SET_BUFFERS_GEOMETRY:
304 res = dispatchSetBuffersGeometry(args);
306 case NATIVE_WINDOW_SET_BUFFERS_TRANSFORM:
307 res = dispatchSetBuffersTransform(args);
309 case NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP:
310 res = dispatchSetBuffersTimestamp(args);
312 case NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS:
313 res = dispatchSetBuffersDimensions(args);
315 case NATIVE_WINDOW_SET_BUFFERS_FORMAT:
316 res = dispatchSetBuffersFormat(args);
318 case NATIVE_WINDOW_LOCK:
319 res = dispatchLock(args);
321 case NATIVE_WINDOW_UNLOCK_AND_POST:
322 res = dispatchUnlockAndPost(args);
324 case NATIVE_WINDOW_SET_SCALING_MODE:
325 res = dispatchSetScalingMode(args);
327 case NATIVE_WINDOW_API_CONNECT:
328 res = dispatchConnect(args);
330 case NATIVE_WINDOW_API_DISCONNECT:
331 res = dispatchDisconnect(args);
334 res = NAME_NOT_FOUND;
340 int SurfaceTextureClient::dispatchConnect(va_list args) {
341 int api = va_arg(args, int);
345 int SurfaceTextureClient::dispatchDisconnect(va_list args) {
346 int api = va_arg(args, int);
347 return disconnect(api);
350 int SurfaceTextureClient::dispatchSetUsage(va_list args) {
351 int usage = va_arg(args, int);
352 return setUsage(usage);
355 int SurfaceTextureClient::dispatchSetCrop(va_list args) {
356 android_native_rect_t const* rect = va_arg(args, android_native_rect_t*);
357 return setCrop(reinterpret_cast<Rect const*>(rect));
360 int SurfaceTextureClient::dispatchSetBufferCount(va_list args) {
361 size_t bufferCount = va_arg(args, size_t);
362 return setBufferCount(bufferCount);
365 int SurfaceTextureClient::dispatchSetBuffersGeometry(va_list args) {
366 int w = va_arg(args, int);
367 int h = va_arg(args, int);
368 int f = va_arg(args, int);
369 int err = setBuffersDimensions(w, h);
373 return setBuffersFormat(f);
376 int SurfaceTextureClient::dispatchSetBuffersDimensions(va_list args) {
377 int w = va_arg(args, int);
378 int h = va_arg(args, int);
379 return setBuffersDimensions(w, h);
382 int SurfaceTextureClient::dispatchSetBuffersFormat(va_list args) {
383 int f = va_arg(args, int);
384 return setBuffersFormat(f);
387 int SurfaceTextureClient::dispatchSetScalingMode(va_list args) {
388 int m = va_arg(args, int);
389 return setScalingMode(m);
392 int SurfaceTextureClient::dispatchSetBuffersTransform(va_list args) {
393 int transform = va_arg(args, int);
394 return setBuffersTransform(transform);
397 int SurfaceTextureClient::dispatchSetBuffersTimestamp(va_list args) {
398 int64_t timestamp = va_arg(args, int64_t);
399 return setBuffersTimestamp(timestamp);
402 int SurfaceTextureClient::dispatchLock(va_list args) {
403 ANativeWindow_Buffer* outBuffer = va_arg(args, ANativeWindow_Buffer*);
404 ARect* inOutDirtyBounds = va_arg(args, ARect*);
405 return lock(outBuffer, inOutDirtyBounds);
408 int SurfaceTextureClient::dispatchUnlockAndPost(va_list args) {
409 return unlockAndPost();
413 int SurfaceTextureClient::connect(int api) {
415 ALOGV("SurfaceTextureClient::connect");
416 Mutex::Autolock lock(mMutex);
417 int err = mSurfaceTexture->connect(api,
418 &mDefaultWidth, &mDefaultHeight, &mTransformHint);
419 if (!err && api == NATIVE_WINDOW_API_CPU) {
420 mConnectedToCpu = true;
425 int SurfaceTextureClient::disconnect(int api) {
427 ALOGV("SurfaceTextureClient::disconnect");
428 Mutex::Autolock lock(mMutex);
430 int err = mSurfaceTexture->disconnect(api);
436 if (api == NATIVE_WINDOW_API_CPU) {
437 mConnectedToCpu = false;
443 int SurfaceTextureClient::setUsage(uint32_t reqUsage)
445 ALOGV("SurfaceTextureClient::setUsage");
446 Mutex::Autolock lock(mMutex);
447 mReqUsage = reqUsage;
451 int SurfaceTextureClient::setCrop(Rect const* rect)
454 ALOGV("SurfaceTextureClient::setCrop");
455 Mutex::Autolock lock(mMutex);
458 if (rect == NULL || rect->isEmpty()) {
459 realRect = Rect(0, 0);
464 status_t err = mSurfaceTexture->setCrop(*rect);
465 ALOGE_IF(err, "ISurfaceTexture::setCrop(...) returned %s", strerror(-err));
470 int SurfaceTextureClient::setBufferCount(int bufferCount)
473 ALOGV("SurfaceTextureClient::setBufferCount");
474 Mutex::Autolock lock(mMutex);
476 status_t err = mSurfaceTexture->setBufferCount(bufferCount);
477 ALOGE_IF(err, "ISurfaceTexture::setBufferCount(%d) returned %s",
478 bufferCount, strerror(-err));
480 if (err == NO_ERROR) {
487 int SurfaceTextureClient::setBuffersDimensions(int w, int h)
490 ALOGV("SurfaceTextureClient::setBuffersDimensions");
491 Mutex::Autolock lock(mMutex);
496 if ((w && !h) || (!w && h))
502 status_t err = mSurfaceTexture->setCrop(Rect(0, 0));
503 ALOGE_IF(err, "ISurfaceTexture::setCrop(...) returned %s", strerror(-err));
508 int SurfaceTextureClient::setBuffersFormat(int format)
510 ALOGV("SurfaceTextureClient::setBuffersFormat");
511 Mutex::Autolock lock(mMutex);
521 int SurfaceTextureClient::setScalingMode(int mode)
524 ALOGV("SurfaceTextureClient::setScalingMode(%d)", mode);
525 Mutex::Autolock lock(mMutex);
526 // mode is validated on the server
527 status_t err = mSurfaceTexture->setScalingMode(mode);
528 ALOGE_IF(err, "ISurfaceTexture::setScalingMode(%d) returned %s",
529 mode, strerror(-err));
534 int SurfaceTextureClient::setBuffersTransform(int transform)
537 ALOGV("SurfaceTextureClient::setBuffersTransform");
538 Mutex::Autolock lock(mMutex);
539 status_t err = mSurfaceTexture->setTransform(transform);
543 int SurfaceTextureClient::setBuffersTimestamp(int64_t timestamp)
545 ALOGV("SurfaceTextureClient::setBuffersTimestamp");
546 Mutex::Autolock lock(mMutex);
547 mTimestamp = timestamp;
551 void SurfaceTextureClient::freeAllBuffers() {
552 for (int i = 0; i < NUM_BUFFER_SLOTS; i++) {
557 // ----------------------------------------------------------------------
558 // the lock/unlock APIs must be used from the same thread
560 static status_t copyBlt(
561 const sp<GraphicBuffer>& dst,
562 const sp<GraphicBuffer>& src,
565 // src and dst with, height and format must be identical. no verification
568 uint8_t const * src_bits = NULL;
569 err = src->lock(GRALLOC_USAGE_SW_READ_OFTEN, reg.bounds(), (void**)&src_bits);
570 ALOGE_IF(err, "error locking src buffer %s", strerror(-err));
572 uint8_t* dst_bits = NULL;
573 err = dst->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, reg.bounds(), (void**)&dst_bits);
574 ALOGE_IF(err, "error locking dst buffer %s", strerror(-err));
576 Region::const_iterator head(reg.begin());
577 Region::const_iterator tail(reg.end());
578 if (head != tail && src_bits && dst_bits) {
579 const size_t bpp = bytesPerPixel(src->format);
580 const size_t dbpr = dst->stride * bpp;
581 const size_t sbpr = src->stride * bpp;
583 while (head != tail) {
584 const Rect& r(*head++);
585 ssize_t h = r.height();
586 if (h <= 0) continue;
587 size_t size = r.width() * bpp;
588 uint8_t const * s = src_bits + (r.left + src->stride * r.top) * bpp;
589 uint8_t * d = dst_bits + (r.left + dst->stride * r.top) * bpp;
590 if (dbpr==sbpr && size==sbpr) {
611 // ----------------------------------------------------------------------------
613 status_t SurfaceTextureClient::lock(
614 ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds)
616 if (mLockedBuffer != 0) {
617 ALOGE("Surface::lock failed, already locked");
618 return INVALID_OPERATION;
621 if (!mConnectedToCpu) {
622 int err = SurfaceTextureClient::connect(NATIVE_WINDOW_API_CPU);
626 // we're intending to do software rendering from this point
627 setUsage(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN);
630 ANativeWindowBuffer* out;
631 status_t err = dequeueBuffer(&out);
632 ALOGE_IF(err, "dequeueBuffer failed (%s)", strerror(-err));
633 if (err == NO_ERROR) {
634 sp<GraphicBuffer> backBuffer(GraphicBuffer::getSelf(out));
635 err = lockBuffer(backBuffer.get());
636 ALOGE_IF(err, "lockBuffer (handle=%p) failed (%s)",
637 backBuffer->handle, strerror(-err));
638 if (err == NO_ERROR) {
639 const Rect bounds(backBuffer->width, backBuffer->height);
641 Region newDirtyRegion;
642 if (inOutDirtyBounds) {
643 newDirtyRegion.set(static_cast<Rect const&>(*inOutDirtyBounds));
644 newDirtyRegion.andSelf(bounds);
646 newDirtyRegion.set(bounds);
649 // figure out if we can copy the frontbuffer back
650 const sp<GraphicBuffer>& frontBuffer(mPostedBuffer);
651 const bool canCopyBack = (frontBuffer != 0 &&
652 backBuffer->width == frontBuffer->width &&
653 backBuffer->height == frontBuffer->height &&
654 backBuffer->format == frontBuffer->format);
657 // copy the area that is invalid and not repainted this round
658 const Region copyback(mOldDirtyRegion.subtract(newDirtyRegion));
659 if (!copyback.isEmpty())
660 copyBlt(backBuffer, frontBuffer, copyback);
662 // if we can't copy-back anything, modify the user's dirty
663 // region to make sure they redraw the whole buffer
664 newDirtyRegion.set(bounds);
667 // keep track of the are of the buffer that is "clean"
668 // (ie: that will be redrawn)
669 mOldDirtyRegion = newDirtyRegion;
671 if (inOutDirtyBounds) {
672 *inOutDirtyBounds = newDirtyRegion.getBounds();
676 status_t res = backBuffer->lock(
677 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
678 newDirtyRegion.bounds(), &vaddr);
680 ALOGW_IF(res, "failed locking buffer (handle = %p)",
683 mLockedBuffer = backBuffer;
684 outBuffer->width = backBuffer->width;
685 outBuffer->height = backBuffer->height;
686 outBuffer->stride = backBuffer->stride;
687 outBuffer->format = backBuffer->format;
688 outBuffer->bits = vaddr;
694 status_t SurfaceTextureClient::unlockAndPost()
696 if (mLockedBuffer == 0) {
697 ALOGE("Surface::unlockAndPost failed, no locked buffer");
698 return INVALID_OPERATION;
701 status_t err = mLockedBuffer->unlock();
702 ALOGE_IF(err, "failed unlocking buffer (%p)", mLockedBuffer->handle);
704 err = queueBuffer(mLockedBuffer.get());
705 ALOGE_IF(err, "queueBuffer (handle=%p) failed (%s)",
706 mLockedBuffer->handle, strerror(-err));
708 mPostedBuffer = mLockedBuffer;
713 }; // namespace android