The Tor Browser / file comparison

comparison: widget/gonk/nativewindow/IGonkGraphicBufferConsumer.cpp

widget/gonk/nativewindow/IGonkGraphicBufferConsumer.cpp

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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial