1 /*
2 * Copyright (C) 2013 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 EGL_EGLEXT_PROTOTYPES
18
19 #include <EGL/egl.h>
20 #include <EGL/eglext.h>
21
22
23 #include <stdint.h>
24 #include <sys/types.h>
25
26 #include <utils/Errors.h>
27
28 #include <binder/Parcel.h>
29 #include <binder/IInterface.h>
30
31 #include <gui/IConsumerListener.h>
32 #include <gui/IGraphicBufferConsumer.h>
33
34 #include <ui/GraphicBuffer.h>
35 #include <ui/Fence.h>
36
37 #include <system/window.h>
38
39 namespace android {
40 // ---------------------------------------------------------------------------
41
BufferItem()42 IGraphicBufferConsumer::BufferItem::BufferItem() :
43 mTransform(0),
44 mScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE),
45 mTimestamp(0),
46 mIsAutoTimestamp(false),
47 mFrameNumber(0),
48 mBuf(INVALID_BUFFER_SLOT),
49 mIsDroppable(false),
50 mAcquireCalled(false),
51 mTransformToDisplayInverse(false) {
52 mCrop.makeInvalid();
53 }
54
getPodSize() const55 size_t IGraphicBufferConsumer::BufferItem::getPodSize() const {
56 size_t c = sizeof(mCrop) +
57 sizeof(mTransform) +
58 sizeof(mScalingMode) +
59 sizeof(mTimestamp) +
60 sizeof(mIsAutoTimestamp) +
61 sizeof(mFrameNumber) +
62 sizeof(mBuf) +
63 sizeof(mIsDroppable) +
64 sizeof(mAcquireCalled) +
65 sizeof(mTransformToDisplayInverse);
66 return c;
67 }
68
getFlattenedSize() const69 size_t IGraphicBufferConsumer::BufferItem::getFlattenedSize() const {
70 size_t c = 0;
71 if (mGraphicBuffer != 0) {
72 c += mGraphicBuffer->getFlattenedSize();
73 FlattenableUtils::align<4>(c);
74 }
75 if (mFence != 0) {
76 c += mFence->getFlattenedSize();
77 FlattenableUtils::align<4>(c);
78 }
79 return sizeof(int32_t) + c + getPodSize();
80 }
81
getFdCount() const82 size_t IGraphicBufferConsumer::BufferItem::getFdCount() const {
83 size_t c = 0;
84 if (mGraphicBuffer != 0) {
85 c += mGraphicBuffer->getFdCount();
86 }
87 if (mFence != 0) {
88 c += mFence->getFdCount();
89 }
90 return c;
91 }
92
flatten(void * & buffer,size_t & size,int * & fds,size_t & count) const93 status_t IGraphicBufferConsumer::BufferItem::flatten(
94 void*& buffer, size_t& size, int*& fds, size_t& count) const {
95
96 // make sure we have enough space
97 if (count < BufferItem::getFlattenedSize()) {
98 return NO_MEMORY;
99 }
100
101 // content flags are stored first
102 uint32_t& flags = *static_cast<uint32_t*>(buffer);
103
104 // advance the pointer
105 FlattenableUtils::advance(buffer, size, sizeof(uint32_t));
106
107 flags = 0;
108 if (mGraphicBuffer != 0) {
109 status_t err = mGraphicBuffer->flatten(buffer, size, fds, count);
110 if (err) return err;
111 size -= FlattenableUtils::align<4>(buffer);
112 flags |= 1;
113 }
114 if (mFence != 0) {
115 status_t err = mFence->flatten(buffer, size, fds, count);
116 if (err) return err;
117 size -= FlattenableUtils::align<4>(buffer);
118 flags |= 2;
119 }
120
121 // check we have enough space (in case flattening the fence/graphicbuffer lied to us)
122 if (size < getPodSize()) {
123 return NO_MEMORY;
124 }
125
126 FlattenableUtils::write(buffer, size, mCrop);
127 FlattenableUtils::write(buffer, size, mTransform);
128 FlattenableUtils::write(buffer, size, mScalingMode);
129 FlattenableUtils::write(buffer, size, mTimestamp);
130 FlattenableUtils::write(buffer, size, mIsAutoTimestamp);
131 FlattenableUtils::write(buffer, size, mFrameNumber);
132 FlattenableUtils::write(buffer, size, mBuf);
133 FlattenableUtils::write(buffer, size, mIsDroppable);
134 FlattenableUtils::write(buffer, size, mAcquireCalled);
135 FlattenableUtils::write(buffer, size, mTransformToDisplayInverse);
136
137 return NO_ERROR;
138 }
139
unflatten(void const * & buffer,size_t & size,int const * & fds,size_t & count)140 status_t IGraphicBufferConsumer::BufferItem::unflatten(
141 void const*& buffer, size_t& size, int const*& fds, size_t& count) {
142
143 if (size < sizeof(uint32_t))
144 return NO_MEMORY;
145
146 uint32_t flags = 0;
147 FlattenableUtils::read(buffer, size, flags);
148
149 if (flags & 1) {
150 mGraphicBuffer = new GraphicBuffer();
151 status_t err = mGraphicBuffer->unflatten(buffer, size, fds, count);
152 if (err) return err;
153 size -= FlattenableUtils::align<4>(buffer);
154 }
155
156 if (flags & 2) {
157 mFence = new Fence();
158 status_t err = mFence->unflatten(buffer, size, fds, count);
159 if (err) return err;
160 size -= FlattenableUtils::align<4>(buffer);
161 }
162
163 // check we have enough space
164 if (size < getPodSize()) {
165 return NO_MEMORY;
166 }
167
168 FlattenableUtils::read(buffer, size, mCrop);
169 FlattenableUtils::read(buffer, size, mTransform);
170 FlattenableUtils::read(buffer, size, mScalingMode);
171 FlattenableUtils::read(buffer, size, mTimestamp);
172 FlattenableUtils::read(buffer, size, mIsAutoTimestamp);
173 FlattenableUtils::read(buffer, size, mFrameNumber);
174 FlattenableUtils::read(buffer, size, mBuf);
175 FlattenableUtils::read(buffer, size, mIsDroppable);
176 FlattenableUtils::read(buffer, size, mAcquireCalled);
177 FlattenableUtils::read(buffer, size, mTransformToDisplayInverse);
178
179 return NO_ERROR;
180 }
181
182 // ---------------------------------------------------------------------------
183
184 enum {
185 ACQUIRE_BUFFER = IBinder::FIRST_CALL_TRANSACTION,
186 RELEASE_BUFFER,
187 CONSUMER_CONNECT,
188 CONSUMER_DISCONNECT,
189 GET_RELEASED_BUFFERS,
190 SET_DEFAULT_BUFFER_SIZE,
191 SET_DEFAULT_MAX_BUFFER_COUNT,
192 DISABLE_ASYNC_BUFFER,
193 SET_MAX_ACQUIRED_BUFFER_COUNT,
194 SET_CONSUMER_NAME,
195 SET_DEFAULT_BUFFER_FORMAT,
196 SET_CONSUMER_USAGE_BITS,
197 SET_TRANSFORM_HINT,
198 DUMP,
199 };
200
201
202 class BpGraphicBufferConsumer : public BpInterface<IGraphicBufferConsumer>
203 {
204 public:
BpGraphicBufferConsumer(const sp<IBinder> & impl)205 BpGraphicBufferConsumer(const sp<IBinder>& impl)
206 : BpInterface<IGraphicBufferConsumer>(impl)
207 {
208 }
209
acquireBuffer(BufferItem * buffer,nsecs_t presentWhen)210 virtual status_t acquireBuffer(BufferItem *buffer, nsecs_t presentWhen) {
211 Parcel data, reply;
212 data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
213 data.writeInt64(presentWhen);
214 status_t result = remote()->transact(ACQUIRE_BUFFER, data, &reply);
215 if (result != NO_ERROR) {
216 return result;
217 }
218 result = reply.read(*buffer);
219 if (result != NO_ERROR) {
220 return result;
221 }
222 return reply.readInt32();
223 }
224
releaseBuffer(int buf,uint64_t frameNumber,EGLDisplay display,EGLSyncKHR fence,const sp<Fence> & releaseFence)225 virtual status_t releaseBuffer(int buf, uint64_t frameNumber,
226 EGLDisplay display, EGLSyncKHR fence,
227 const sp<Fence>& releaseFence) {
228 Parcel data, reply;
229 data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
230 data.writeInt32(buf);
231 data.writeInt64(frameNumber);
232 data.write(*releaseFence);
233 status_t result = remote()->transact(RELEASE_BUFFER, data, &reply);
234 if (result != NO_ERROR) {
235 return result;
236 }
237 return reply.readInt32();
238 }
239
consumerConnect(const sp<IConsumerListener> & consumer,bool controlledByApp)240 virtual status_t consumerConnect(const sp<IConsumerListener>& consumer, bool controlledByApp) {
241 Parcel data, reply;
242 data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
243 data.writeStrongBinder(consumer->asBinder());
244 data.writeInt32(controlledByApp);
245 status_t result = remote()->transact(CONSUMER_CONNECT, data, &reply);
246 if (result != NO_ERROR) {
247 return result;
248 }
249 return reply.readInt32();
250 }
251
consumerDisconnect()252 virtual status_t consumerDisconnect() {
253 Parcel data, reply;
254 data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
255 status_t result = remote()->transact(CONSUMER_DISCONNECT, data, &reply);
256 if (result != NO_ERROR) {
257 return result;
258 }
259 return reply.readInt32();
260 }
261
getReleasedBuffers(uint32_t * slotMask)262 virtual status_t getReleasedBuffers(uint32_t* slotMask) {
263 Parcel data, reply;
264 data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
265 status_t result = remote()->transact(GET_RELEASED_BUFFERS, data, &reply);
266 if (result != NO_ERROR) {
267 return result;
268 }
269 *slotMask = reply.readInt32();
270 return reply.readInt32();
271 }
272
setDefaultBufferSize(uint32_t w,uint32_t h)273 virtual status_t setDefaultBufferSize(uint32_t w, uint32_t h) {
274 Parcel data, reply;
275 data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
276 data.writeInt32(w);
277 data.writeInt32(h);
278 status_t result = remote()->transact(SET_DEFAULT_BUFFER_SIZE, data, &reply);
279 if (result != NO_ERROR) {
280 return result;
281 }
282 return reply.readInt32();
283 }
284
setDefaultMaxBufferCount(int bufferCount)285 virtual status_t setDefaultMaxBufferCount(int bufferCount) {
286 Parcel data, reply;
287 data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
288 data.writeInt32(bufferCount);
289 status_t result = remote()->transact(SET_DEFAULT_MAX_BUFFER_COUNT, data, &reply);
290 if (result != NO_ERROR) {
291 return result;
292 }
293 return reply.readInt32();
294 }
295
disableAsyncBuffer()296 virtual status_t disableAsyncBuffer() {
297 Parcel data, reply;
298 data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
299 status_t result = remote()->transact(DISABLE_ASYNC_BUFFER, data, &reply);
300 if (result != NO_ERROR) {
301 return result;
302 }
303 return reply.readInt32();
304 }
305
setMaxAcquiredBufferCount(int maxAcquiredBuffers)306 virtual status_t setMaxAcquiredBufferCount(int maxAcquiredBuffers) {
307 Parcel data, reply;
308 data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
309 data.writeInt32(maxAcquiredBuffers);
310 status_t result = remote()->transact(SET_MAX_ACQUIRED_BUFFER_COUNT, data, &reply);
311 if (result != NO_ERROR) {
312 return result;
313 }
314 return reply.readInt32();
315 }
316
setConsumerName(const String8 & name)317 virtual void setConsumerName(const String8& name) {
318 Parcel data, reply;
319 data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
320 data.writeString8(name);
321 remote()->transact(SET_CONSUMER_NAME, data, &reply);
322 }
323
setDefaultBufferFormat(uint32_t defaultFormat)324 virtual status_t setDefaultBufferFormat(uint32_t defaultFormat) {
325 Parcel data, reply;
326 data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
327 data.writeInt32(defaultFormat);
328 status_t result = remote()->transact(SET_DEFAULT_BUFFER_FORMAT, data, &reply);
329 if (result != NO_ERROR) {
330 return result;
331 }
332 return reply.readInt32();
333 }
334
setConsumerUsageBits(uint32_t usage)335 virtual status_t setConsumerUsageBits(uint32_t usage) {
336 Parcel data, reply;
337 data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
338 data.writeInt32(usage);
339 status_t result = remote()->transact(SET_CONSUMER_USAGE_BITS, data, &reply);
340 if (result != NO_ERROR) {
341 return result;
342 }
343 return reply.readInt32();
344 }
345
setTransformHint(uint32_t hint)346 virtual status_t setTransformHint(uint32_t hint) {
347 Parcel data, reply;
348 data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
349 data.writeInt32(hint);
350 status_t result = remote()->transact(SET_TRANSFORM_HINT, data, &reply);
351 if (result != NO_ERROR) {
352 return result;
353 }
354 return reply.readInt32();
355 }
356
dump(String8 & result,const char * prefix) const357 virtual void dump(String8& result, const char* prefix) const {
358 Parcel data, reply;
359 data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
360 data.writeString8(result);
361 data.writeString8(String8(prefix ? prefix : ""));
362 remote()->transact(DUMP, data, &reply);
363 reply.readString8();
364 }
365 };
366
367 IMPLEMENT_META_INTERFACE(GraphicBufferConsumer, "android.gui.IGraphicBufferConsumer");
368
369 // ----------------------------------------------------------------------
370
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)371 status_t BnGraphicBufferConsumer::onTransact(
372 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
373 {
374 switch(code) {
375 case ACQUIRE_BUFFER: {
376 CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
377 BufferItem item;
378 int64_t presentWhen = data.readInt64();
379 status_t result = acquireBuffer(&item, presentWhen);
380 status_t err = reply->write(item);
381 if (err) return err;
382 reply->writeInt32(result);
383 return NO_ERROR;
384 } break;
385 case RELEASE_BUFFER: {
386 CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
387 int buf = data.readInt32();
388 uint64_t frameNumber = data.readInt64();
389 sp<Fence> releaseFence = new Fence();
390 status_t err = data.read(*releaseFence);
391 if (err) return err;
392 status_t result = releaseBuffer(buf, frameNumber,
393 EGL_NO_DISPLAY, EGL_NO_SYNC_KHR, releaseFence);
394 reply->writeInt32(result);
395 return NO_ERROR;
396 } break;
397 case CONSUMER_CONNECT: {
398 CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
399 sp<IConsumerListener> consumer = IConsumerListener::asInterface( data.readStrongBinder() );
400 bool controlledByApp = data.readInt32();
401 status_t result = consumerConnect(consumer, controlledByApp);
402 reply->writeInt32(result);
403 return NO_ERROR;
404 } break;
405 case CONSUMER_DISCONNECT: {
406 CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
407 status_t result = consumerDisconnect();
408 reply->writeInt32(result);
409 return NO_ERROR;
410 } break;
411 case GET_RELEASED_BUFFERS: {
412 CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
413 uint32_t slotMask;
414 status_t result = getReleasedBuffers(&slotMask);
415 reply->writeInt32(slotMask);
416 reply->writeInt32(result);
417 return NO_ERROR;
418 } break;
419 case SET_DEFAULT_BUFFER_SIZE: {
420 CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
421 uint32_t w = data.readInt32();
422 uint32_t h = data.readInt32();
423 status_t result = setDefaultBufferSize(w, h);
424 reply->writeInt32(result);
425 return NO_ERROR;
426 } break;
427 case SET_DEFAULT_MAX_BUFFER_COUNT: {
428 CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
429 uint32_t bufferCount = data.readInt32();
430 status_t result = setDefaultMaxBufferCount(bufferCount);
431 reply->writeInt32(result);
432 return NO_ERROR;
433 } break;
434 case DISABLE_ASYNC_BUFFER: {
435 CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
436 status_t result = disableAsyncBuffer();
437 reply->writeInt32(result);
438 return NO_ERROR;
439 } break;
440 case SET_MAX_ACQUIRED_BUFFER_COUNT: {
441 CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
442 uint32_t maxAcquiredBuffers = data.readInt32();
443 status_t result = setMaxAcquiredBufferCount(maxAcquiredBuffers);
444 reply->writeInt32(result);
445 return NO_ERROR;
446 } break;
447 case SET_CONSUMER_NAME: {
448 CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
449 setConsumerName( data.readString8() );
450 return NO_ERROR;
451 } break;
452 case SET_DEFAULT_BUFFER_FORMAT: {
453 CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
454 uint32_t defaultFormat = data.readInt32();
455 status_t result = setDefaultBufferFormat(defaultFormat);
456 reply->writeInt32(result);
457 return NO_ERROR;
458 } break;
459 case SET_CONSUMER_USAGE_BITS: {
460 CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
461 uint32_t usage = data.readInt32();
462 status_t result = setConsumerUsageBits(usage);
463 reply->writeInt32(result);
464 return NO_ERROR;
465 } break;
466 case SET_TRANSFORM_HINT: {
467 CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
468 uint32_t hint = data.readInt32();
469 status_t result = setTransformHint(hint);
470 reply->writeInt32(result);
471 return NO_ERROR;
472 } break;
473 case DUMP: {
474 CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
475 String8 result = data.readString8();
476 String8 prefix = data.readString8();
477 static_cast<IGraphicBufferConsumer*>(this)->dump(result, prefix);
478 reply->writeString8(result);
479 return NO_ERROR;
480 }
481 }
482 return BBinder::onTransact(code, data, reply, flags);
483 }
484
485 }; // namespace android
486