1 /*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
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
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
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.
15 */
16
17 #define LOG_TAG "SurfaceTextureClient"
18 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
19 //#define LOG_NDEBUG 0
20
21 #include <android/native_window.h>
22
23 #include <utils/Log.h>
24 #include <utils/Trace.h>
25
26 #include <ui/Fence.h>
27
28 #include <gui/ISurfaceComposer.h>
29 #include <gui/SurfaceComposerClient.h>
30 #include <gui/SurfaceTexture.h>
31 #include <gui/SurfaceTextureClient.h>
32
33 #include <private/gui/ComposerService.h>
34
35 namespace android {
36
SurfaceTextureClient(const sp<ISurfaceTexture> & surfaceTexture)37 SurfaceTextureClient::SurfaceTextureClient(
38 const sp<ISurfaceTexture>& surfaceTexture)
39 {
40 SurfaceTextureClient::init();
41 SurfaceTextureClient::setISurfaceTexture(surfaceTexture);
42 }
43
44 // see SurfaceTextureClient.h
SurfaceTextureClient(const sp<SurfaceTexture> & surfaceTexture)45 SurfaceTextureClient::SurfaceTextureClient(const
46 sp<SurfaceTexture>& surfaceTexture)
47 {
48 SurfaceTextureClient::init();
49 SurfaceTextureClient::setISurfaceTexture(surfaceTexture->getBufferQueue());
50 }
51
SurfaceTextureClient()52 SurfaceTextureClient::SurfaceTextureClient() {
53 SurfaceTextureClient::init();
54 }
55
~SurfaceTextureClient()56 SurfaceTextureClient::~SurfaceTextureClient() {
57 if (mConnectedToCpu) {
58 SurfaceTextureClient::disconnect(NATIVE_WINDOW_API_CPU);
59 }
60 }
61
init()62 void SurfaceTextureClient::init() {
63 // Initialize the ANativeWindow function pointers.
64 ANativeWindow::setSwapInterval = hook_setSwapInterval;
65 ANativeWindow::dequeueBuffer = hook_dequeueBuffer;
66 ANativeWindow::cancelBuffer = hook_cancelBuffer;
67 ANativeWindow::queueBuffer = hook_queueBuffer;
68 ANativeWindow::query = hook_query;
69 ANativeWindow::perform = hook_perform;
70
71 ANativeWindow::dequeueBuffer_DEPRECATED = hook_dequeueBuffer_DEPRECATED;
72 ANativeWindow::cancelBuffer_DEPRECATED = hook_cancelBuffer_DEPRECATED;
73 ANativeWindow::lockBuffer_DEPRECATED = hook_lockBuffer_DEPRECATED;
74 ANativeWindow::queueBuffer_DEPRECATED = hook_queueBuffer_DEPRECATED;
75
76 const_cast<int&>(ANativeWindow::minSwapInterval) = 0;
77 const_cast<int&>(ANativeWindow::maxSwapInterval) = 1;
78
79 mReqWidth = 0;
80 mReqHeight = 0;
81 mReqFormat = 0;
82 mReqUsage = 0;
83 mTimestamp = NATIVE_WINDOW_TIMESTAMP_AUTO;
84 mCrop.clear();
85 mScalingMode = NATIVE_WINDOW_SCALING_MODE_FREEZE;
86 mTransform = 0;
87 mDefaultWidth = 0;
88 mDefaultHeight = 0;
89 mUserWidth = 0;
90 mUserHeight = 0;
91 mTransformHint = 0;
92 mConsumerRunningBehind = false;
93 mConnectedToCpu = false;
94 }
95
setISurfaceTexture(const sp<ISurfaceTexture> & surfaceTexture)96 void SurfaceTextureClient::setISurfaceTexture(
97 const sp<ISurfaceTexture>& surfaceTexture)
98 {
99 mSurfaceTexture = surfaceTexture;
100 }
101
getISurfaceTexture() const102 sp<ISurfaceTexture> SurfaceTextureClient::getISurfaceTexture() const {
103 return mSurfaceTexture;
104 }
105
hook_setSwapInterval(ANativeWindow * window,int interval)106 int SurfaceTextureClient::hook_setSwapInterval(ANativeWindow* window, int interval) {
107 SurfaceTextureClient* c = getSelf(window);
108 return c->setSwapInterval(interval);
109 }
110
hook_dequeueBuffer(ANativeWindow * window,ANativeWindowBuffer ** buffer,int * fenceFd)111 int SurfaceTextureClient::hook_dequeueBuffer(ANativeWindow* window,
112 ANativeWindowBuffer** buffer, int* fenceFd) {
113 SurfaceTextureClient* c = getSelf(window);
114 return c->dequeueBuffer(buffer, fenceFd);
115 }
116
hook_cancelBuffer(ANativeWindow * window,ANativeWindowBuffer * buffer,int fenceFd)117 int SurfaceTextureClient::hook_cancelBuffer(ANativeWindow* window,
118 ANativeWindowBuffer* buffer, int fenceFd) {
119 SurfaceTextureClient* c = getSelf(window);
120 return c->cancelBuffer(buffer, fenceFd);
121 }
122
hook_queueBuffer(ANativeWindow * window,ANativeWindowBuffer * buffer,int fenceFd)123 int SurfaceTextureClient::hook_queueBuffer(ANativeWindow* window,
124 ANativeWindowBuffer* buffer, int fenceFd) {
125 SurfaceTextureClient* c = getSelf(window);
126 return c->queueBuffer(buffer, fenceFd);
127 }
128
hook_dequeueBuffer_DEPRECATED(ANativeWindow * window,ANativeWindowBuffer ** buffer)129 int SurfaceTextureClient::hook_dequeueBuffer_DEPRECATED(ANativeWindow* window,
130 ANativeWindowBuffer** buffer) {
131 SurfaceTextureClient* c = getSelf(window);
132 ANativeWindowBuffer* buf;
133 int fenceFd = -1;
134 int result = c->dequeueBuffer(&buf, &fenceFd);
135 sp<Fence> fence(new Fence(fenceFd));
136 int waitResult = fence->waitForever(1000, "dequeueBuffer_DEPRECATED");
137 if (waitResult != OK) {
138 ALOGE("dequeueBuffer_DEPRECATED: Fence::wait returned an error: %d",
139 waitResult);
140 c->cancelBuffer(buf, -1);
141 return waitResult;
142 }
143 *buffer = buf;
144 return result;
145 }
146
hook_cancelBuffer_DEPRECATED(ANativeWindow * window,ANativeWindowBuffer * buffer)147 int SurfaceTextureClient::hook_cancelBuffer_DEPRECATED(ANativeWindow* window,
148 ANativeWindowBuffer* buffer) {
149 SurfaceTextureClient* c = getSelf(window);
150 return c->cancelBuffer(buffer, -1);
151 }
152
hook_lockBuffer_DEPRECATED(ANativeWindow * window,ANativeWindowBuffer * buffer)153 int SurfaceTextureClient::hook_lockBuffer_DEPRECATED(ANativeWindow* window,
154 ANativeWindowBuffer* buffer) {
155 SurfaceTextureClient* c = getSelf(window);
156 return c->lockBuffer_DEPRECATED(buffer);
157 }
158
hook_queueBuffer_DEPRECATED(ANativeWindow * window,ANativeWindowBuffer * buffer)159 int SurfaceTextureClient::hook_queueBuffer_DEPRECATED(ANativeWindow* window,
160 ANativeWindowBuffer* buffer) {
161 SurfaceTextureClient* c = getSelf(window);
162 return c->queueBuffer(buffer, -1);
163 }
164
hook_query(const ANativeWindow * window,int what,int * value)165 int SurfaceTextureClient::hook_query(const ANativeWindow* window,
166 int what, int* value) {
167 const SurfaceTextureClient* c = getSelf(window);
168 return c->query(what, value);
169 }
170
hook_perform(ANativeWindow * window,int operation,...)171 int SurfaceTextureClient::hook_perform(ANativeWindow* window, int operation, ...) {
172 va_list args;
173 va_start(args, operation);
174 SurfaceTextureClient* c = getSelf(window);
175 return c->perform(operation, args);
176 }
177
setSwapInterval(int interval)178 int SurfaceTextureClient::setSwapInterval(int interval) {
179 ATRACE_CALL();
180 // EGL specification states:
181 // interval is silently clamped to minimum and maximum implementation
182 // dependent values before being stored.
183 // Although we don't have to, we apply the same logic here.
184
185 if (interval < minSwapInterval)
186 interval = minSwapInterval;
187
188 if (interval > maxSwapInterval)
189 interval = maxSwapInterval;
190
191 status_t res = mSurfaceTexture->setSynchronousMode(interval ? true : false);
192
193 return res;
194 }
195
dequeueBuffer(android_native_buffer_t ** buffer,int * fenceFd)196 int SurfaceTextureClient::dequeueBuffer(android_native_buffer_t** buffer,
197 int* fenceFd) {
198 ATRACE_CALL();
199 ALOGV("SurfaceTextureClient::dequeueBuffer");
200 Mutex::Autolock lock(mMutex);
201 int buf = -1;
202 int reqW = mReqWidth ? mReqWidth : mUserWidth;
203 int reqH = mReqHeight ? mReqHeight : mUserHeight;
204 sp<Fence> fence;
205 status_t result = mSurfaceTexture->dequeueBuffer(&buf, fence, reqW, reqH,
206 mReqFormat, mReqUsage);
207 if (result < 0) {
208 ALOGV("dequeueBuffer: ISurfaceTexture::dequeueBuffer(%d, %d, %d, %d)"
209 "failed: %d", mReqWidth, mReqHeight, mReqFormat, mReqUsage,
210 result);
211 return result;
212 }
213 sp<GraphicBuffer>& gbuf(mSlots[buf].buffer);
214 if (result & ISurfaceTexture::RELEASE_ALL_BUFFERS) {
215 freeAllBuffers();
216 }
217
218 if ((result & ISurfaceTexture::BUFFER_NEEDS_REALLOCATION) || gbuf == 0) {
219 result = mSurfaceTexture->requestBuffer(buf, &gbuf);
220 if (result != NO_ERROR) {
221 ALOGE("dequeueBuffer: ISurfaceTexture::requestBuffer failed: %d",
222 result);
223 return result;
224 }
225 }
226
227 if (fence.get()) {
228 *fenceFd = fence->dup();
229 if (*fenceFd == -1) {
230 ALOGE("dequeueBuffer: error duping fence: %d", errno);
231 // dup() should never fail; something is badly wrong. Soldier on
232 // and hope for the best; the worst that should happen is some
233 // visible corruption that lasts until the next frame.
234 }
235 } else {
236 *fenceFd = -1;
237 }
238
239 *buffer = gbuf.get();
240 return OK;
241 }
242
cancelBuffer(android_native_buffer_t * buffer,int fenceFd)243 int SurfaceTextureClient::cancelBuffer(android_native_buffer_t* buffer,
244 int fenceFd) {
245 ATRACE_CALL();
246 ALOGV("SurfaceTextureClient::cancelBuffer");
247 Mutex::Autolock lock(mMutex);
248 int i = getSlotFromBufferLocked(buffer);
249 if (i < 0) {
250 return i;
251 }
252 sp<Fence> fence(fenceFd >= 0 ? new Fence(fenceFd) : NULL);
253 mSurfaceTexture->cancelBuffer(i, fence);
254 return OK;
255 }
256
getSlotFromBufferLocked(android_native_buffer_t * buffer) const257 int SurfaceTextureClient::getSlotFromBufferLocked(
258 android_native_buffer_t* buffer) const {
259 bool dumpedState = false;
260 for (int i = 0; i < NUM_BUFFER_SLOTS; i++) {
261 if (mSlots[i].buffer != NULL &&
262 mSlots[i].buffer->handle == buffer->handle) {
263 return i;
264 }
265 }
266 ALOGE("getSlotFromBufferLocked: unknown buffer: %p", buffer->handle);
267 return BAD_VALUE;
268 }
269
lockBuffer_DEPRECATED(android_native_buffer_t * buffer)270 int SurfaceTextureClient::lockBuffer_DEPRECATED(android_native_buffer_t* buffer) {
271 ALOGV("SurfaceTextureClient::lockBuffer");
272 Mutex::Autolock lock(mMutex);
273 return OK;
274 }
275
queueBuffer(android_native_buffer_t * buffer,int fenceFd)276 int SurfaceTextureClient::queueBuffer(android_native_buffer_t* buffer, int fenceFd) {
277 ATRACE_CALL();
278 ALOGV("SurfaceTextureClient::queueBuffer");
279 Mutex::Autolock lock(mMutex);
280 int64_t timestamp;
281 if (mTimestamp == NATIVE_WINDOW_TIMESTAMP_AUTO) {
282 timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
283 ALOGV("SurfaceTextureClient::queueBuffer making up timestamp: %.2f ms",
284 timestamp / 1000000.f);
285 } else {
286 timestamp = mTimestamp;
287 }
288 int i = getSlotFromBufferLocked(buffer);
289 if (i < 0) {
290 return i;
291 }
292
293
294 // Make sure the crop rectangle is entirely inside the buffer.
295 Rect crop;
296 mCrop.intersect(Rect(buffer->width, buffer->height), &crop);
297
298 sp<Fence> fence(fenceFd >= 0 ? new Fence(fenceFd) : NULL);
299 ISurfaceTexture::QueueBufferOutput output;
300 ISurfaceTexture::QueueBufferInput input(timestamp, crop, mScalingMode,
301 mTransform, fence);
302 status_t err = mSurfaceTexture->queueBuffer(i, input, &output);
303 if (err != OK) {
304 ALOGE("queueBuffer: error queuing buffer to SurfaceTexture, %d", err);
305 }
306 uint32_t numPendingBuffers = 0;
307 output.deflate(&mDefaultWidth, &mDefaultHeight, &mTransformHint,
308 &numPendingBuffers);
309
310 mConsumerRunningBehind = (numPendingBuffers >= 2);
311
312 return err;
313 }
314
query(int what,int * value) const315 int SurfaceTextureClient::query(int what, int* value) const {
316 ATRACE_CALL();
317 ALOGV("SurfaceTextureClient::query");
318 { // scope for the lock
319 Mutex::Autolock lock(mMutex);
320 switch (what) {
321 case NATIVE_WINDOW_FORMAT:
322 if (mReqFormat) {
323 *value = mReqFormat;
324 return NO_ERROR;
325 }
326 break;
327 case NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER: {
328 sp<ISurfaceComposer> composer(
329 ComposerService::getComposerService());
330 if (composer->authenticateSurfaceTexture(mSurfaceTexture)) {
331 *value = 1;
332 } else {
333 *value = 0;
334 }
335 return NO_ERROR;
336 }
337 case NATIVE_WINDOW_CONCRETE_TYPE:
338 *value = NATIVE_WINDOW_SURFACE_TEXTURE_CLIENT;
339 return NO_ERROR;
340 case NATIVE_WINDOW_DEFAULT_WIDTH:
341 *value = mUserWidth ? mUserWidth : mDefaultWidth;
342 return NO_ERROR;
343 case NATIVE_WINDOW_DEFAULT_HEIGHT:
344 *value = mUserHeight ? mUserHeight : mDefaultHeight;
345 return NO_ERROR;
346 case NATIVE_WINDOW_TRANSFORM_HINT:
347 *value = mTransformHint;
348 return NO_ERROR;
349 case NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND: {
350 status_t err = NO_ERROR;
351 if (!mConsumerRunningBehind) {
352 *value = 0;
353 } else {
354 err = mSurfaceTexture->query(what, value);
355 if (err == NO_ERROR) {
356 mConsumerRunningBehind = *value;
357 }
358 }
359 return err;
360 }
361 }
362 }
363 return mSurfaceTexture->query(what, value);
364 }
365
perform(int operation,va_list args)366 int SurfaceTextureClient::perform(int operation, va_list args)
367 {
368 int res = NO_ERROR;
369 switch (operation) {
370 case NATIVE_WINDOW_CONNECT:
371 // deprecated. must return NO_ERROR.
372 break;
373 case NATIVE_WINDOW_DISCONNECT:
374 // deprecated. must return NO_ERROR.
375 break;
376 case NATIVE_WINDOW_SET_USAGE:
377 res = dispatchSetUsage(args);
378 break;
379 case NATIVE_WINDOW_SET_CROP:
380 res = dispatchSetCrop(args);
381 break;
382 case NATIVE_WINDOW_SET_BUFFER_COUNT:
383 res = dispatchSetBufferCount(args);
384 break;
385 case NATIVE_WINDOW_SET_BUFFERS_GEOMETRY:
386 res = dispatchSetBuffersGeometry(args);
387 break;
388 case NATIVE_WINDOW_SET_BUFFERS_TRANSFORM:
389 res = dispatchSetBuffersTransform(args);
390 break;
391 case NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP:
392 res = dispatchSetBuffersTimestamp(args);
393 break;
394 case NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS:
395 res = dispatchSetBuffersDimensions(args);
396 break;
397 case NATIVE_WINDOW_SET_BUFFERS_USER_DIMENSIONS:
398 res = dispatchSetBuffersUserDimensions(args);
399 break;
400 case NATIVE_WINDOW_SET_BUFFERS_FORMAT:
401 res = dispatchSetBuffersFormat(args);
402 break;
403 case NATIVE_WINDOW_LOCK:
404 res = dispatchLock(args);
405 break;
406 case NATIVE_WINDOW_UNLOCK_AND_POST:
407 res = dispatchUnlockAndPost(args);
408 break;
409 case NATIVE_WINDOW_SET_SCALING_MODE:
410 res = dispatchSetScalingMode(args);
411 break;
412 case NATIVE_WINDOW_API_CONNECT:
413 res = dispatchConnect(args);
414 break;
415 case NATIVE_WINDOW_API_DISCONNECT:
416 res = dispatchDisconnect(args);
417 break;
418 default:
419 res = NAME_NOT_FOUND;
420 break;
421 }
422 return res;
423 }
424
dispatchConnect(va_list args)425 int SurfaceTextureClient::dispatchConnect(va_list args) {
426 int api = va_arg(args, int);
427 return connect(api);
428 }
429
dispatchDisconnect(va_list args)430 int SurfaceTextureClient::dispatchDisconnect(va_list args) {
431 int api = va_arg(args, int);
432 return disconnect(api);
433 }
434
dispatchSetUsage(va_list args)435 int SurfaceTextureClient::dispatchSetUsage(va_list args) {
436 int usage = va_arg(args, int);
437 return setUsage(usage);
438 }
439
dispatchSetCrop(va_list args)440 int SurfaceTextureClient::dispatchSetCrop(va_list args) {
441 android_native_rect_t const* rect = va_arg(args, android_native_rect_t*);
442 return setCrop(reinterpret_cast<Rect const*>(rect));
443 }
444
dispatchSetBufferCount(va_list args)445 int SurfaceTextureClient::dispatchSetBufferCount(va_list args) {
446 size_t bufferCount = va_arg(args, size_t);
447 return setBufferCount(bufferCount);
448 }
449
dispatchSetBuffersGeometry(va_list args)450 int SurfaceTextureClient::dispatchSetBuffersGeometry(va_list args) {
451 int w = va_arg(args, int);
452 int h = va_arg(args, int);
453 int f = va_arg(args, int);
454 int err = setBuffersDimensions(w, h);
455 if (err != 0) {
456 return err;
457 }
458 return setBuffersFormat(f);
459 }
460
dispatchSetBuffersDimensions(va_list args)461 int SurfaceTextureClient::dispatchSetBuffersDimensions(va_list args) {
462 int w = va_arg(args, int);
463 int h = va_arg(args, int);
464 return setBuffersDimensions(w, h);
465 }
466
dispatchSetBuffersUserDimensions(va_list args)467 int SurfaceTextureClient::dispatchSetBuffersUserDimensions(va_list args) {
468 int w = va_arg(args, int);
469 int h = va_arg(args, int);
470 return setBuffersUserDimensions(w, h);
471 }
472
dispatchSetBuffersFormat(va_list args)473 int SurfaceTextureClient::dispatchSetBuffersFormat(va_list args) {
474 int f = va_arg(args, int);
475 return setBuffersFormat(f);
476 }
477
dispatchSetScalingMode(va_list args)478 int SurfaceTextureClient::dispatchSetScalingMode(va_list args) {
479 int m = va_arg(args, int);
480 return setScalingMode(m);
481 }
482
dispatchSetBuffersTransform(va_list args)483 int SurfaceTextureClient::dispatchSetBuffersTransform(va_list args) {
484 int transform = va_arg(args, int);
485 return setBuffersTransform(transform);
486 }
487
dispatchSetBuffersTimestamp(va_list args)488 int SurfaceTextureClient::dispatchSetBuffersTimestamp(va_list args) {
489 int64_t timestamp = va_arg(args, int64_t);
490 return setBuffersTimestamp(timestamp);
491 }
492
dispatchLock(va_list args)493 int SurfaceTextureClient::dispatchLock(va_list args) {
494 ANativeWindow_Buffer* outBuffer = va_arg(args, ANativeWindow_Buffer*);
495 ARect* inOutDirtyBounds = va_arg(args, ARect*);
496 return lock(outBuffer, inOutDirtyBounds);
497 }
498
dispatchUnlockAndPost(va_list args)499 int SurfaceTextureClient::dispatchUnlockAndPost(va_list args) {
500 return unlockAndPost();
501 }
502
503
connect(int api)504 int SurfaceTextureClient::connect(int api) {
505 ATRACE_CALL();
506 ALOGV("SurfaceTextureClient::connect");
507 Mutex::Autolock lock(mMutex);
508 ISurfaceTexture::QueueBufferOutput output;
509 int err = mSurfaceTexture->connect(api, &output);
510 if (err == NO_ERROR) {
511 uint32_t numPendingBuffers = 0;
512 output.deflate(&mDefaultWidth, &mDefaultHeight, &mTransformHint,
513 &numPendingBuffers);
514 mConsumerRunningBehind = (numPendingBuffers >= 2);
515 }
516 if (!err && api == NATIVE_WINDOW_API_CPU) {
517 mConnectedToCpu = true;
518 }
519 return err;
520 }
521
disconnect(int api)522 int SurfaceTextureClient::disconnect(int api) {
523 ATRACE_CALL();
524 ALOGV("SurfaceTextureClient::disconnect");
525 Mutex::Autolock lock(mMutex);
526 freeAllBuffers();
527 int err = mSurfaceTexture->disconnect(api);
528 if (!err) {
529 mReqFormat = 0;
530 mReqWidth = 0;
531 mReqHeight = 0;
532 mReqUsage = 0;
533 mCrop.clear();
534 mScalingMode = NATIVE_WINDOW_SCALING_MODE_FREEZE;
535 mTransform = 0;
536 if (api == NATIVE_WINDOW_API_CPU) {
537 mConnectedToCpu = false;
538 }
539 }
540 return err;
541 }
542
setUsage(uint32_t reqUsage)543 int SurfaceTextureClient::setUsage(uint32_t reqUsage)
544 {
545 ALOGV("SurfaceTextureClient::setUsage");
546 Mutex::Autolock lock(mMutex);
547 mReqUsage = reqUsage;
548 return OK;
549 }
550
setCrop(Rect const * rect)551 int SurfaceTextureClient::setCrop(Rect const* rect)
552 {
553 ATRACE_CALL();
554
555 Rect realRect;
556 if (rect == NULL || rect->isEmpty()) {
557 realRect.clear();
558 } else {
559 realRect = *rect;
560 }
561
562 ALOGV("SurfaceTextureClient::setCrop rect=[%d %d %d %d]",
563 realRect.left, realRect.top, realRect.right, realRect.bottom);
564
565 Mutex::Autolock lock(mMutex);
566 mCrop = realRect;
567 return NO_ERROR;
568 }
569
setBufferCount(int bufferCount)570 int SurfaceTextureClient::setBufferCount(int bufferCount)
571 {
572 ATRACE_CALL();
573 ALOGV("SurfaceTextureClient::setBufferCount");
574 Mutex::Autolock lock(mMutex);
575
576 status_t err = mSurfaceTexture->setBufferCount(bufferCount);
577 ALOGE_IF(err, "ISurfaceTexture::setBufferCount(%d) returned %s",
578 bufferCount, strerror(-err));
579
580 if (err == NO_ERROR) {
581 freeAllBuffers();
582 }
583
584 return err;
585 }
586
setBuffersDimensions(int w,int h)587 int SurfaceTextureClient::setBuffersDimensions(int w, int h)
588 {
589 ATRACE_CALL();
590 ALOGV("SurfaceTextureClient::setBuffersDimensions");
591
592 if (w<0 || h<0)
593 return BAD_VALUE;
594
595 if ((w && !h) || (!w && h))
596 return BAD_VALUE;
597
598 Mutex::Autolock lock(mMutex);
599 mReqWidth = w;
600 mReqHeight = h;
601 return NO_ERROR;
602 }
603
setBuffersUserDimensions(int w,int h)604 int SurfaceTextureClient::setBuffersUserDimensions(int w, int h)
605 {
606 ATRACE_CALL();
607 ALOGV("SurfaceTextureClient::setBuffersUserDimensions");
608
609 if (w<0 || h<0)
610 return BAD_VALUE;
611
612 if ((w && !h) || (!w && h))
613 return BAD_VALUE;
614
615 Mutex::Autolock lock(mMutex);
616 mUserWidth = w;
617 mUserHeight = h;
618 return NO_ERROR;
619 }
620
setBuffersFormat(int format)621 int SurfaceTextureClient::setBuffersFormat(int format)
622 {
623 ALOGV("SurfaceTextureClient::setBuffersFormat");
624
625 if (format<0)
626 return BAD_VALUE;
627
628 Mutex::Autolock lock(mMutex);
629 mReqFormat = format;
630 return NO_ERROR;
631 }
632
setScalingMode(int mode)633 int SurfaceTextureClient::setScalingMode(int mode)
634 {
635 ATRACE_CALL();
636 ALOGV("SurfaceTextureClient::setScalingMode(%d)", mode);
637
638 switch (mode) {
639 case NATIVE_WINDOW_SCALING_MODE_FREEZE:
640 case NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW:
641 case NATIVE_WINDOW_SCALING_MODE_SCALE_CROP:
642 break;
643 default:
644 ALOGE("unknown scaling mode: %d", mode);
645 return BAD_VALUE;
646 }
647
648 Mutex::Autolock lock(mMutex);
649 mScalingMode = mode;
650 return NO_ERROR;
651 }
652
setBuffersTransform(int transform)653 int SurfaceTextureClient::setBuffersTransform(int transform)
654 {
655 ATRACE_CALL();
656 ALOGV("SurfaceTextureClient::setBuffersTransform");
657 Mutex::Autolock lock(mMutex);
658 mTransform = transform;
659 return NO_ERROR;
660 }
661
setBuffersTimestamp(int64_t timestamp)662 int SurfaceTextureClient::setBuffersTimestamp(int64_t timestamp)
663 {
664 ALOGV("SurfaceTextureClient::setBuffersTimestamp");
665 Mutex::Autolock lock(mMutex);
666 mTimestamp = timestamp;
667 return NO_ERROR;
668 }
669
freeAllBuffers()670 void SurfaceTextureClient::freeAllBuffers() {
671 for (int i = 0; i < NUM_BUFFER_SLOTS; i++) {
672 mSlots[i].buffer = 0;
673 }
674 }
675
676 // ----------------------------------------------------------------------
677 // the lock/unlock APIs must be used from the same thread
678
copyBlt(const sp<GraphicBuffer> & dst,const sp<GraphicBuffer> & src,const Region & reg)679 static status_t copyBlt(
680 const sp<GraphicBuffer>& dst,
681 const sp<GraphicBuffer>& src,
682 const Region& reg)
683 {
684 // src and dst with, height and format must be identical. no verification
685 // is done here.
686 status_t err;
687 uint8_t const * src_bits = NULL;
688 err = src->lock(GRALLOC_USAGE_SW_READ_OFTEN, reg.bounds(), (void**)&src_bits);
689 ALOGE_IF(err, "error locking src buffer %s", strerror(-err));
690
691 uint8_t* dst_bits = NULL;
692 err = dst->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, reg.bounds(), (void**)&dst_bits);
693 ALOGE_IF(err, "error locking dst buffer %s", strerror(-err));
694
695 Region::const_iterator head(reg.begin());
696 Region::const_iterator tail(reg.end());
697 if (head != tail && src_bits && dst_bits) {
698 const size_t bpp = bytesPerPixel(src->format);
699 const size_t dbpr = dst->stride * bpp;
700 const size_t sbpr = src->stride * bpp;
701
702 while (head != tail) {
703 const Rect& r(*head++);
704 ssize_t h = r.height();
705 if (h <= 0) continue;
706 size_t size = r.width() * bpp;
707 uint8_t const * s = src_bits + (r.left + src->stride * r.top) * bpp;
708 uint8_t * d = dst_bits + (r.left + dst->stride * r.top) * bpp;
709 if (dbpr==sbpr && size==sbpr) {
710 size *= h;
711 h = 1;
712 }
713 do {
714 memcpy(d, s, size);
715 d += dbpr;
716 s += sbpr;
717 } while (--h > 0);
718 }
719 }
720
721 if (src_bits)
722 src->unlock();
723
724 if (dst_bits)
725 dst->unlock();
726
727 return err;
728 }
729
730 // ----------------------------------------------------------------------------
731
lock(ANativeWindow_Buffer * outBuffer,ARect * inOutDirtyBounds)732 status_t SurfaceTextureClient::lock(
733 ANativeWindow_Buffer* outBuffer, ARect* inOutDirtyBounds)
734 {
735 if (mLockedBuffer != 0) {
736 ALOGE("Surface::lock failed, already locked");
737 return INVALID_OPERATION;
738 }
739
740 if (!mConnectedToCpu) {
741 int err = SurfaceTextureClient::connect(NATIVE_WINDOW_API_CPU);
742 if (err) {
743 return err;
744 }
745 // we're intending to do software rendering from this point
746 setUsage(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN);
747 }
748
749 ANativeWindowBuffer* out;
750 int fenceFd = -1;
751 status_t err = dequeueBuffer(&out, &fenceFd);
752 ALOGE_IF(err, "dequeueBuffer failed (%s)", strerror(-err));
753 if (err == NO_ERROR) {
754 sp<GraphicBuffer> backBuffer(GraphicBuffer::getSelf(out));
755 sp<Fence> fence(new Fence(fenceFd));
756
757 err = fence->waitForever(1000, "SurfaceTextureClient::lock");
758 if (err != OK) {
759 ALOGE("Fence::wait failed (%s)", strerror(-err));
760 cancelBuffer(out, fenceFd);
761 return err;
762 }
763
764 const Rect bounds(backBuffer->width, backBuffer->height);
765
766 Region newDirtyRegion;
767 if (inOutDirtyBounds) {
768 newDirtyRegion.set(static_cast<Rect const&>(*inOutDirtyBounds));
769 newDirtyRegion.andSelf(bounds);
770 } else {
771 newDirtyRegion.set(bounds);
772 }
773
774 // figure out if we can copy the frontbuffer back
775 const sp<GraphicBuffer>& frontBuffer(mPostedBuffer);
776 const bool canCopyBack = (frontBuffer != 0 &&
777 backBuffer->width == frontBuffer->width &&
778 backBuffer->height == frontBuffer->height &&
779 backBuffer->format == frontBuffer->format);
780
781 if (canCopyBack) {
782 // copy the area that is invalid and not repainted this round
783 const Region copyback(mDirtyRegion.subtract(newDirtyRegion));
784 if (!copyback.isEmpty())
785 copyBlt(backBuffer, frontBuffer, copyback);
786 } else {
787 // if we can't copy-back anything, modify the user's dirty
788 // region to make sure they redraw the whole buffer
789 newDirtyRegion.set(bounds);
790 mDirtyRegion.clear();
791 Mutex::Autolock lock(mMutex);
792 for (size_t i=0 ; i<NUM_BUFFER_SLOTS ; i++) {
793 mSlots[i].dirtyRegion.clear();
794 }
795 }
796
797
798 { // scope for the lock
799 Mutex::Autolock lock(mMutex);
800 int backBufferSlot(getSlotFromBufferLocked(backBuffer.get()));
801 if (backBufferSlot >= 0) {
802 Region& dirtyRegion(mSlots[backBufferSlot].dirtyRegion);
803 mDirtyRegion.subtract(dirtyRegion);
804 dirtyRegion = newDirtyRegion;
805 }
806 }
807
808 mDirtyRegion.orSelf(newDirtyRegion);
809 if (inOutDirtyBounds) {
810 *inOutDirtyBounds = newDirtyRegion.getBounds();
811 }
812
813 void* vaddr;
814 status_t res = backBuffer->lock(
815 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
816 newDirtyRegion.bounds(), &vaddr);
817
818 ALOGW_IF(res, "failed locking buffer (handle = %p)",
819 backBuffer->handle);
820
821 if (res != 0) {
822 err = INVALID_OPERATION;
823 } else {
824 mLockedBuffer = backBuffer;
825 outBuffer->width = backBuffer->width;
826 outBuffer->height = backBuffer->height;
827 outBuffer->stride = backBuffer->stride;
828 outBuffer->format = backBuffer->format;
829 outBuffer->bits = vaddr;
830 }
831 }
832 return err;
833 }
834
unlockAndPost()835 status_t SurfaceTextureClient::unlockAndPost()
836 {
837 if (mLockedBuffer == 0) {
838 ALOGE("Surface::unlockAndPost failed, no locked buffer");
839 return INVALID_OPERATION;
840 }
841
842 status_t err = mLockedBuffer->unlock();
843 ALOGE_IF(err, "failed unlocking buffer (%p)", mLockedBuffer->handle);
844
845 err = queueBuffer(mLockedBuffer.get(), -1);
846 ALOGE_IF(err, "queueBuffer (handle=%p) failed (%s)",
847 mLockedBuffer->handle, strerror(-err));
848
849 mPostedBuffer = mLockedBuffer;
850 mLockedBuffer = 0;
851 return err;
852 }
853
854 }; // namespace android
855