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 #include <stdint.h>
18 #include <sys/types.h>
19
20 #include <utils/Errors.h>
21 #include <utils/NativeHandle.h>
22 #include <utils/RefBase.h>
23 #include <utils/String8.h>
24 #include <utils/Timers.h>
25 #include <utils/Vector.h>
26
27 #include <binder/Parcel.h>
28 #include <binder/IInterface.h>
29
30 #ifndef NO_BUFFERHUB
31 #include <gui/BufferHubProducer.h>
32 #endif
33
34 #include <gui/bufferqueue/1.0/H2BGraphicBufferProducer.h>
35 #include <gui/bufferqueue/2.0/H2BGraphicBufferProducer.h>
36 #include <gui/BufferQueueDefs.h>
37 #include <gui/IGraphicBufferProducer.h>
38 #include <gui/IProducerListener.h>
39
40 namespace android {
41 // ----------------------------------------------------------------------------
42
43 using H2BGraphicBufferProducerV1_0 =
44 ::android::hardware::graphics::bufferqueue::V1_0::utils::
45 H2BGraphicBufferProducer;
46 using H2BGraphicBufferProducerV2_0 =
47 ::android::hardware::graphics::bufferqueue::V2_0::utils::
48 H2BGraphicBufferProducer;
49
50 enum {
51 REQUEST_BUFFER = IBinder::FIRST_CALL_TRANSACTION,
52 DEQUEUE_BUFFER,
53 DETACH_BUFFER,
54 DETACH_NEXT_BUFFER,
55 ATTACH_BUFFER,
56 QUEUE_BUFFER,
57 CANCEL_BUFFER,
58 QUERY,
59 CONNECT,
60 DISCONNECT,
61 SET_SIDEBAND_STREAM,
62 ALLOCATE_BUFFERS,
63 ALLOW_ALLOCATION,
64 SET_GENERATION_NUMBER,
65 GET_CONSUMER_NAME,
66 SET_MAX_DEQUEUED_BUFFER_COUNT,
67 SET_ASYNC_MODE,
68 SET_SHARED_BUFFER_MODE,
69 SET_AUTO_REFRESH,
70 SET_DEQUEUE_TIMEOUT,
71 GET_LAST_QUEUED_BUFFER,
72 GET_FRAME_TIMESTAMPS,
73 GET_UNIQUE_ID,
74 GET_CONSUMER_USAGE,
75 SET_LEGACY_BUFFER_DROP,
76 SET_AUTO_PREROTATION,
77 };
78
79 class BpGraphicBufferProducer : public BpInterface<IGraphicBufferProducer>
80 {
81 public:
BpGraphicBufferProducer(const sp<IBinder> & impl)82 explicit BpGraphicBufferProducer(const sp<IBinder>& impl)
83 : BpInterface<IGraphicBufferProducer>(impl)
84 {
85 }
86
87 ~BpGraphicBufferProducer() override;
88
requestBuffer(int bufferIdx,sp<GraphicBuffer> * buf)89 virtual status_t requestBuffer(int bufferIdx, sp<GraphicBuffer>* buf) {
90 Parcel data, reply;
91 data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
92 data.writeInt32(bufferIdx);
93 status_t result =remote()->transact(REQUEST_BUFFER, data, &reply);
94 if (result != NO_ERROR) {
95 return result;
96 }
97 bool nonNull = reply.readInt32();
98 if (nonNull) {
99 *buf = new GraphicBuffer();
100 result = reply.read(**buf);
101 if(result != NO_ERROR) {
102 (*buf).clear();
103 return result;
104 }
105 }
106 result = reply.readInt32();
107 return result;
108 }
109
setMaxDequeuedBufferCount(int maxDequeuedBuffers)110 virtual status_t setMaxDequeuedBufferCount(int maxDequeuedBuffers) {
111 Parcel data, reply;
112 data.writeInterfaceToken(
113 IGraphicBufferProducer::getInterfaceDescriptor());
114 data.writeInt32(maxDequeuedBuffers);
115 status_t result = remote()->transact(SET_MAX_DEQUEUED_BUFFER_COUNT,
116 data, &reply);
117 if (result != NO_ERROR) {
118 return result;
119 }
120 result = reply.readInt32();
121 return result;
122 }
123
setAsyncMode(bool async)124 virtual status_t setAsyncMode(bool async) {
125 Parcel data, reply;
126 data.writeInterfaceToken(
127 IGraphicBufferProducer::getInterfaceDescriptor());
128 data.writeInt32(async);
129 status_t result = remote()->transact(SET_ASYNC_MODE,
130 data, &reply);
131 if (result != NO_ERROR) {
132 return result;
133 }
134 result = reply.readInt32();
135 return result;
136 }
137
dequeueBuffer(int * buf,sp<Fence> * fence,uint32_t width,uint32_t height,PixelFormat format,uint64_t usage,uint64_t * outBufferAge,FrameEventHistoryDelta * outTimestamps)138 virtual status_t dequeueBuffer(int* buf, sp<Fence>* fence, uint32_t width, uint32_t height,
139 PixelFormat format, uint64_t usage, uint64_t* outBufferAge,
140 FrameEventHistoryDelta* outTimestamps) {
141 Parcel data, reply;
142 bool getFrameTimestamps = (outTimestamps != nullptr);
143
144 data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
145 data.writeUint32(width);
146 data.writeUint32(height);
147 data.writeInt32(static_cast<int32_t>(format));
148 data.writeUint64(usage);
149 data.writeBool(getFrameTimestamps);
150
151 status_t result = remote()->transact(DEQUEUE_BUFFER, data, &reply);
152 if (result != NO_ERROR) {
153 return result;
154 }
155
156 *buf = reply.readInt32();
157 *fence = new Fence();
158 result = reply.read(**fence);
159 if (result != NO_ERROR) {
160 fence->clear();
161 return result;
162 }
163 if (outBufferAge) {
164 result = reply.readUint64(outBufferAge);
165 } else {
166 // Read the value even if outBufferAge is nullptr:
167 uint64_t bufferAge;
168 result = reply.readUint64(&bufferAge);
169 }
170 if (result != NO_ERROR) {
171 ALOGE("IGBP::dequeueBuffer failed to read buffer age: %d", result);
172 return result;
173 }
174 if (getFrameTimestamps) {
175 result = reply.read(*outTimestamps);
176 if (result != NO_ERROR) {
177 ALOGE("IGBP::dequeueBuffer failed to read timestamps: %d",
178 result);
179 return result;
180 }
181 }
182 result = reply.readInt32();
183 return result;
184 }
185
detachBuffer(int slot)186 virtual status_t detachBuffer(int slot) {
187 Parcel data, reply;
188 data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
189 data.writeInt32(slot);
190 status_t result = remote()->transact(DETACH_BUFFER, data, &reply);
191 if (result != NO_ERROR) {
192 return result;
193 }
194 result = reply.readInt32();
195 return result;
196 }
197
detachNextBuffer(sp<GraphicBuffer> * outBuffer,sp<Fence> * outFence)198 virtual status_t detachNextBuffer(sp<GraphicBuffer>* outBuffer,
199 sp<Fence>* outFence) {
200 if (outBuffer == nullptr) {
201 ALOGE("detachNextBuffer: outBuffer must not be NULL");
202 return BAD_VALUE;
203 } else if (outFence == nullptr) {
204 ALOGE("detachNextBuffer: outFence must not be NULL");
205 return BAD_VALUE;
206 }
207 Parcel data, reply;
208 data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
209 status_t result = remote()->transact(DETACH_NEXT_BUFFER, data, &reply);
210 if (result != NO_ERROR) {
211 return result;
212 }
213 result = reply.readInt32();
214 if (result == NO_ERROR) {
215 bool nonNull = reply.readInt32();
216 if (nonNull) {
217 *outBuffer = new GraphicBuffer;
218 result = reply.read(**outBuffer);
219 if (result != NO_ERROR) {
220 outBuffer->clear();
221 return result;
222 }
223 }
224 nonNull = reply.readInt32();
225 if (nonNull) {
226 *outFence = new Fence;
227 result = reply.read(**outFence);
228 if (result != NO_ERROR) {
229 outBuffer->clear();
230 outFence->clear();
231 return result;
232 }
233 }
234 }
235 return result;
236 }
237
attachBuffer(int * slot,const sp<GraphicBuffer> & buffer)238 virtual status_t attachBuffer(int* slot, const sp<GraphicBuffer>& buffer) {
239 Parcel data, reply;
240 data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
241 data.write(*buffer.get());
242 status_t result = remote()->transact(ATTACH_BUFFER, data, &reply);
243 if (result != NO_ERROR) {
244 return result;
245 }
246
247 *slot = reply.readInt32();
248 result = reply.readInt32();
249 if (result == NO_ERROR &&
250 (*slot < 0 || *slot >= BufferQueueDefs::NUM_BUFFER_SLOTS)) {
251 ALOGE("attachBuffer returned invalid slot %d", *slot);
252 android_errorWriteLog(0x534e4554, "37478824");
253 return UNKNOWN_ERROR;
254 }
255
256 return result;
257 }
258
queueBuffer(int buf,const QueueBufferInput & input,QueueBufferOutput * output)259 virtual status_t queueBuffer(int buf,
260 const QueueBufferInput& input, QueueBufferOutput* output) {
261 Parcel data, reply;
262
263 data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
264 data.writeInt32(buf);
265 data.write(input);
266
267 status_t result = remote()->transact(QUEUE_BUFFER, data, &reply);
268 if (result != NO_ERROR) {
269 return result;
270 }
271
272 result = reply.read(*output);
273 if (result != NO_ERROR) {
274 return result;
275 }
276
277 result = reply.readInt32();
278 return result;
279 }
280
cancelBuffer(int buf,const sp<Fence> & fence)281 virtual status_t cancelBuffer(int buf, const sp<Fence>& fence) {
282 Parcel data, reply;
283 data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
284 data.writeInt32(buf);
285 data.write(*fence.get());
286 status_t result = remote()->transact(CANCEL_BUFFER, data, &reply);
287 if (result != NO_ERROR) {
288 return result;
289 }
290 result = reply.readInt32();
291 return result;
292 }
293
query(int what,int * value)294 virtual int query(int what, int* value) {
295 Parcel data, reply;
296 data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
297 data.writeInt32(what);
298 status_t result = remote()->transact(QUERY, data, &reply);
299 if (result != NO_ERROR) {
300 return result;
301 }
302 value[0] = reply.readInt32();
303 result = reply.readInt32();
304 return result;
305 }
306
connect(const sp<IProducerListener> & listener,int api,bool producerControlledByApp,QueueBufferOutput * output)307 virtual status_t connect(const sp<IProducerListener>& listener,
308 int api, bool producerControlledByApp, QueueBufferOutput* output) {
309 Parcel data, reply;
310 data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
311 if (listener != nullptr) {
312 data.writeInt32(1);
313 data.writeStrongBinder(IInterface::asBinder(listener));
314 } else {
315 data.writeInt32(0);
316 }
317 data.writeInt32(api);
318 data.writeInt32(producerControlledByApp);
319 status_t result = remote()->transact(CONNECT, data, &reply);
320 if (result != NO_ERROR) {
321 return result;
322 }
323 reply.read(*output);
324 result = reply.readInt32();
325 return result;
326 }
327
disconnect(int api,DisconnectMode mode)328 virtual status_t disconnect(int api, DisconnectMode mode) {
329 Parcel data, reply;
330 data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
331 data.writeInt32(api);
332 data.writeInt32(static_cast<int32_t>(mode));
333 status_t result =remote()->transact(DISCONNECT, data, &reply);
334 if (result != NO_ERROR) {
335 return result;
336 }
337 result = reply.readInt32();
338 return result;
339 }
340
setSidebandStream(const sp<NativeHandle> & stream)341 virtual status_t setSidebandStream(const sp<NativeHandle>& stream) {
342 Parcel data, reply;
343 status_t result;
344 data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
345 if (stream.get()) {
346 data.writeInt32(true);
347 data.writeNativeHandle(stream->handle());
348 } else {
349 data.writeInt32(false);
350 }
351 if ((result = remote()->transact(SET_SIDEBAND_STREAM, data, &reply)) == NO_ERROR) {
352 result = reply.readInt32();
353 }
354 return result;
355 }
356
allocateBuffers(uint32_t width,uint32_t height,PixelFormat format,uint64_t usage)357 virtual void allocateBuffers(uint32_t width, uint32_t height,
358 PixelFormat format, uint64_t usage) {
359 Parcel data, reply;
360 data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
361 data.writeUint32(width);
362 data.writeUint32(height);
363 data.writeInt32(static_cast<int32_t>(format));
364 data.writeUint64(usage);
365 status_t result = remote()->transact(ALLOCATE_BUFFERS, data, &reply, IBinder::FLAG_ONEWAY);
366 if (result != NO_ERROR) {
367 ALOGE("allocateBuffers failed to transact: %d", result);
368 }
369 }
370
allowAllocation(bool allow)371 virtual status_t allowAllocation(bool allow) {
372 Parcel data, reply;
373 data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
374 data.writeInt32(static_cast<int32_t>(allow));
375 status_t result = remote()->transact(ALLOW_ALLOCATION, data, &reply);
376 if (result != NO_ERROR) {
377 return result;
378 }
379 result = reply.readInt32();
380 return result;
381 }
382
setGenerationNumber(uint32_t generationNumber)383 virtual status_t setGenerationNumber(uint32_t generationNumber) {
384 Parcel data, reply;
385 data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
386 data.writeUint32(generationNumber);
387 status_t result = remote()->transact(SET_GENERATION_NUMBER, data, &reply);
388 if (result == NO_ERROR) {
389 result = reply.readInt32();
390 }
391 return result;
392 }
393
getConsumerName() const394 virtual String8 getConsumerName() const {
395 Parcel data, reply;
396 data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
397 status_t result = remote()->transact(GET_CONSUMER_NAME, data, &reply);
398 if (result != NO_ERROR) {
399 ALOGE("getConsumerName failed to transact: %d", result);
400 return String8("TransactFailed");
401 }
402 return reply.readString8();
403 }
404
setSharedBufferMode(bool sharedBufferMode)405 virtual status_t setSharedBufferMode(bool sharedBufferMode) {
406 Parcel data, reply;
407 data.writeInterfaceToken(
408 IGraphicBufferProducer::getInterfaceDescriptor());
409 data.writeInt32(sharedBufferMode);
410 status_t result = remote()->transact(SET_SHARED_BUFFER_MODE, data,
411 &reply);
412 if (result == NO_ERROR) {
413 result = reply.readInt32();
414 }
415 return result;
416 }
417
setAutoRefresh(bool autoRefresh)418 virtual status_t setAutoRefresh(bool autoRefresh) {
419 Parcel data, reply;
420 data.writeInterfaceToken(
421 IGraphicBufferProducer::getInterfaceDescriptor());
422 data.writeInt32(autoRefresh);
423 status_t result = remote()->transact(SET_AUTO_REFRESH, data, &reply);
424 if (result == NO_ERROR) {
425 result = reply.readInt32();
426 }
427 return result;
428 }
429
setDequeueTimeout(nsecs_t timeout)430 virtual status_t setDequeueTimeout(nsecs_t timeout) {
431 Parcel data, reply;
432 data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
433 data.writeInt64(timeout);
434 status_t result = remote()->transact(SET_DEQUEUE_TIMEOUT, data, &reply);
435 if (result != NO_ERROR) {
436 ALOGE("setDequeueTimeout failed to transact: %d", result);
437 return result;
438 }
439 return reply.readInt32();
440 }
441
setLegacyBufferDrop(bool drop)442 virtual status_t setLegacyBufferDrop(bool drop) {
443 Parcel data, reply;
444 data.writeInterfaceToken(
445 IGraphicBufferProducer::getInterfaceDescriptor());
446 data.writeInt32(drop);
447 status_t result = remote()->transact(SET_LEGACY_BUFFER_DROP,
448 data, &reply);
449 if (result != NO_ERROR) {
450 return result;
451 }
452 result = reply.readInt32();
453 return result;
454 }
455
getLastQueuedBuffer(sp<GraphicBuffer> * outBuffer,sp<Fence> * outFence,float outTransformMatrix[16])456 virtual status_t getLastQueuedBuffer(sp<GraphicBuffer>* outBuffer,
457 sp<Fence>* outFence, float outTransformMatrix[16]) override {
458 Parcel data, reply;
459 data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
460 status_t result = remote()->transact(GET_LAST_QUEUED_BUFFER, data,
461 &reply);
462 if (result != NO_ERROR) {
463 ALOGE("getLastQueuedBuffer failed to transact: %d", result);
464 return result;
465 }
466 result = reply.readInt32();
467 if (result != NO_ERROR) {
468 return result;
469 }
470 bool hasBuffer = reply.readBool();
471 sp<GraphicBuffer> buffer;
472 if (hasBuffer) {
473 buffer = new GraphicBuffer();
474 result = reply.read(*buffer);
475 if (result == NO_ERROR) {
476 result = reply.read(outTransformMatrix, sizeof(float) * 16);
477 }
478 }
479 if (result != NO_ERROR) {
480 ALOGE("getLastQueuedBuffer failed to read buffer: %d", result);
481 return result;
482 }
483 sp<Fence> fence(new Fence);
484 result = reply.read(*fence);
485 if (result != NO_ERROR) {
486 ALOGE("getLastQueuedBuffer failed to read fence: %d", result);
487 return result;
488 }
489 *outBuffer = buffer;
490 *outFence = fence;
491 return result;
492 }
493
getFrameTimestamps(FrameEventHistoryDelta * outDelta)494 virtual void getFrameTimestamps(FrameEventHistoryDelta* outDelta) {
495 Parcel data, reply;
496 status_t result = data.writeInterfaceToken(
497 IGraphicBufferProducer::getInterfaceDescriptor());
498 if (result != NO_ERROR) {
499 ALOGE("IGBP::getFrameTimestamps failed to write token: %d", result);
500 return;
501 }
502 result = remote()->transact(GET_FRAME_TIMESTAMPS, data, &reply);
503 if (result != NO_ERROR) {
504 ALOGE("IGBP::getFrameTimestamps failed to transact: %d", result);
505 return;
506 }
507 result = reply.read(*outDelta);
508 if (result != NO_ERROR) {
509 ALOGE("IGBP::getFrameTimestamps failed to read timestamps: %d",
510 result);
511 }
512 }
513
getUniqueId(uint64_t * outId) const514 virtual status_t getUniqueId(uint64_t* outId) const {
515 Parcel data, reply;
516 data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
517 status_t result = remote()->transact(GET_UNIQUE_ID, data, &reply);
518 if (result != NO_ERROR) {
519 ALOGE("getUniqueId failed to transact: %d", result);
520 }
521 status_t actualResult = NO_ERROR;
522 result = reply.readInt32(&actualResult);
523 if (result != NO_ERROR) {
524 return result;
525 }
526 result = reply.readUint64(outId);
527 if (result != NO_ERROR) {
528 return result;
529 }
530 return actualResult;
531 }
532
getConsumerUsage(uint64_t * outUsage) const533 virtual status_t getConsumerUsage(uint64_t* outUsage) const {
534 Parcel data, reply;
535 data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
536 status_t result = remote()->transact(GET_CONSUMER_USAGE, data, &reply);
537 if (result != NO_ERROR) {
538 ALOGE("getConsumerUsage failed to transact: %d", result);
539 }
540 status_t actualResult = NO_ERROR;
541 result = reply.readInt32(&actualResult);
542 if (result != NO_ERROR) {
543 return result;
544 }
545 result = reply.readUint64(outUsage);
546 if (result != NO_ERROR) {
547 return result;
548 }
549 return actualResult;
550 }
551
setAutoPrerotation(bool autoPrerotation)552 virtual status_t setAutoPrerotation(bool autoPrerotation) {
553 Parcel data, reply;
554 data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
555 data.writeBool(autoPrerotation);
556 status_t result = remote()->transact(SET_AUTO_PREROTATION, data, &reply);
557 if (result == NO_ERROR) {
558 result = reply.readInt32();
559 }
560 return result;
561 }
562 };
563
564 // Out-of-line virtual method definition to trigger vtable emission in this
565 // translation unit (see clang warning -Wweak-vtables)
~BpGraphicBufferProducer()566 BpGraphicBufferProducer::~BpGraphicBufferProducer() {}
567
568 class HpGraphicBufferProducer : public HpInterface<
569 BpGraphicBufferProducer,
570 H2BGraphicBufferProducerV1_0,
571 H2BGraphicBufferProducerV2_0> {
572 public:
HpGraphicBufferProducer(const sp<IBinder> & base)573 explicit HpGraphicBufferProducer(const sp<IBinder>& base) : PBase(base) {}
574
requestBuffer(int slot,sp<GraphicBuffer> * buf)575 status_t requestBuffer(int slot, sp<GraphicBuffer>* buf) override {
576 return mBase->requestBuffer(slot, buf);
577 }
578
setMaxDequeuedBufferCount(int maxDequeuedBuffers)579 status_t setMaxDequeuedBufferCount(int maxDequeuedBuffers) override {
580 return mBase->setMaxDequeuedBufferCount(maxDequeuedBuffers);
581 }
582
setAsyncMode(bool async)583 status_t setAsyncMode(bool async) override {
584 return mBase->setAsyncMode(async);
585 }
586
dequeueBuffer(int * slot,sp<Fence> * fence,uint32_t w,uint32_t h,PixelFormat format,uint64_t usage,uint64_t * outBufferAge,FrameEventHistoryDelta * outTimestamps)587 status_t dequeueBuffer(int* slot, sp<Fence>* fence, uint32_t w, uint32_t h, PixelFormat format,
588 uint64_t usage, uint64_t* outBufferAge,
589 FrameEventHistoryDelta* outTimestamps) override {
590 return mBase->dequeueBuffer(slot, fence, w, h, format, usage, outBufferAge, outTimestamps);
591 }
592
detachBuffer(int slot)593 status_t detachBuffer(int slot) override {
594 return mBase->detachBuffer(slot);
595 }
596
detachNextBuffer(sp<GraphicBuffer> * outBuffer,sp<Fence> * outFence)597 status_t detachNextBuffer(
598 sp<GraphicBuffer>* outBuffer, sp<Fence>* outFence) override {
599 return mBase->detachNextBuffer(outBuffer, outFence);
600 }
601
attachBuffer(int * outSlot,const sp<GraphicBuffer> & buffer)602 status_t attachBuffer(
603 int* outSlot, const sp<GraphicBuffer>& buffer) override {
604 return mBase->attachBuffer(outSlot, buffer);
605 }
606
queueBuffer(int slot,const QueueBufferInput & input,QueueBufferOutput * output)607 status_t queueBuffer(
608 int slot,
609 const QueueBufferInput& input,
610 QueueBufferOutput* output) override {
611 return mBase->queueBuffer(slot, input, output);
612 }
613
cancelBuffer(int slot,const sp<Fence> & fence)614 status_t cancelBuffer(int slot, const sp<Fence>& fence) override {
615 return mBase->cancelBuffer(slot, fence);
616 }
617
query(int what,int * value)618 int query(int what, int* value) override {
619 return mBase->query(what, value);
620 }
621
connect(const sp<IProducerListener> & listener,int api,bool producerControlledByApp,QueueBufferOutput * output)622 status_t connect(
623 const sp<IProducerListener>& listener,
624 int api, bool producerControlledByApp,
625 QueueBufferOutput* output) override {
626 return mBase->connect(listener, api, producerControlledByApp, output);
627 }
628
disconnect(int api,DisconnectMode mode=DisconnectMode::Api)629 status_t disconnect(
630 int api, DisconnectMode mode = DisconnectMode::Api) override {
631 return mBase->disconnect(api, mode);
632 }
633
setSidebandStream(const sp<NativeHandle> & stream)634 status_t setSidebandStream(const sp<NativeHandle>& stream) override {
635 return mBase->setSidebandStream(stream);
636 }
637
allocateBuffers(uint32_t width,uint32_t height,PixelFormat format,uint64_t usage)638 void allocateBuffers(uint32_t width, uint32_t height,
639 PixelFormat format, uint64_t usage) override {
640 return mBase->allocateBuffers(width, height, format, usage);
641 }
642
allowAllocation(bool allow)643 status_t allowAllocation(bool allow) override {
644 return mBase->allowAllocation(allow);
645 }
646
setGenerationNumber(uint32_t generationNumber)647 status_t setGenerationNumber(uint32_t generationNumber) override {
648 return mBase->setGenerationNumber(generationNumber);
649 }
650
getConsumerName() const651 String8 getConsumerName() const override {
652 return mBase->getConsumerName();
653 }
654
setSharedBufferMode(bool sharedBufferMode)655 status_t setSharedBufferMode(bool sharedBufferMode) override {
656 return mBase->setSharedBufferMode(sharedBufferMode);
657 }
658
setAutoRefresh(bool autoRefresh)659 status_t setAutoRefresh(bool autoRefresh) override {
660 return mBase->setAutoRefresh(autoRefresh);
661 }
662
setDequeueTimeout(nsecs_t timeout)663 status_t setDequeueTimeout(nsecs_t timeout) override {
664 return mBase->setDequeueTimeout(timeout);
665 }
666
setLegacyBufferDrop(bool drop)667 status_t setLegacyBufferDrop(bool drop) override {
668 return mBase->setLegacyBufferDrop(drop);
669 }
670
getLastQueuedBuffer(sp<GraphicBuffer> * outBuffer,sp<Fence> * outFence,float outTransformMatrix[16])671 status_t getLastQueuedBuffer(
672 sp<GraphicBuffer>* outBuffer,
673 sp<Fence>* outFence,
674 float outTransformMatrix[16]) override {
675 return mBase->getLastQueuedBuffer(
676 outBuffer, outFence, outTransformMatrix);
677 }
678
getFrameTimestamps(FrameEventHistoryDelta * outDelta)679 void getFrameTimestamps(FrameEventHistoryDelta* outDelta) override {
680 return mBase->getFrameTimestamps(outDelta);
681 }
682
getUniqueId(uint64_t * outId) const683 status_t getUniqueId(uint64_t* outId) const override {
684 return mBase->getUniqueId(outId);
685 }
686
getConsumerUsage(uint64_t * outUsage) const687 status_t getConsumerUsage(uint64_t* outUsage) const override {
688 return mBase->getConsumerUsage(outUsage);
689 }
690
setAutoPrerotation(bool autoPrerotation)691 status_t setAutoPrerotation(bool autoPrerotation) override {
692 return mBase->setAutoPrerotation(autoPrerotation);
693 }
694 };
695
696 IMPLEMENT_HYBRID_META_INTERFACE(GraphicBufferProducer,
697 "android.gui.IGraphicBufferProducer");
698
699 // ----------------------------------------------------------------------
700
setLegacyBufferDrop(bool drop)701 status_t IGraphicBufferProducer::setLegacyBufferDrop(bool drop) {
702 // No-op for IGBP other than BufferQueue.
703 (void) drop;
704 return INVALID_OPERATION;
705 }
706
setAutoPrerotation(bool autoPrerotation)707 status_t IGraphicBufferProducer::setAutoPrerotation(bool autoPrerotation) {
708 // No-op for IGBP other than BufferQueue.
709 (void)autoPrerotation;
710 return INVALID_OPERATION;
711 }
712
exportToParcel(Parcel * parcel)713 status_t IGraphicBufferProducer::exportToParcel(Parcel* parcel) {
714 status_t res = OK;
715 res = parcel->writeUint32(USE_BUFFER_QUEUE);
716 if (res != NO_ERROR) {
717 ALOGE("exportToParcel: Cannot write magic, res=%d.", res);
718 return res;
719 }
720
721 return parcel->writeStrongBinder(IInterface::asBinder(this));
722 }
723
724 /* static */
exportToParcel(const sp<IGraphicBufferProducer> & producer,Parcel * parcel)725 status_t IGraphicBufferProducer::exportToParcel(const sp<IGraphicBufferProducer>& producer,
726 Parcel* parcel) {
727 if (parcel == nullptr) {
728 ALOGE("exportToParcel: Invalid parcel object.");
729 return BAD_VALUE;
730 }
731
732 if (producer == nullptr) {
733 status_t res = OK;
734 res = parcel->writeUint32(IGraphicBufferProducer::USE_BUFFER_QUEUE);
735 if (res != NO_ERROR) return res;
736 return parcel->writeStrongBinder(nullptr);
737 } else {
738 return producer->exportToParcel(parcel);
739 }
740 }
741
742 /* static */
createFromParcel(const Parcel * parcel)743 sp<IGraphicBufferProducer> IGraphicBufferProducer::createFromParcel(const Parcel* parcel) {
744 uint32_t outMagic = 0;
745 status_t res = NO_ERROR;
746
747 res = parcel->readUint32(&outMagic);
748 if (res != NO_ERROR) {
749 ALOGE("createFromParcel: Failed to read magic, error=%d.", res);
750 return nullptr;
751 }
752
753 switch (outMagic) {
754 case USE_BUFFER_QUEUE: {
755 sp<IBinder> binder;
756 res = parcel->readNullableStrongBinder(&binder);
757 if (res != NO_ERROR) {
758 ALOGE("createFromParcel: Can't read strong binder.");
759 return nullptr;
760 }
761 return interface_cast<IGraphicBufferProducer>(binder);
762 }
763 case USE_BUFFER_HUB: {
764 ALOGE("createFromParcel: BufferHub not implemented.");
765 #ifndef NO_BUFFERHUB
766 dvr::ProducerQueueParcelable producerParcelable;
767 res = producerParcelable.readFromParcel(parcel);
768 if (res != NO_ERROR) {
769 ALOGE("createFromParcel: Failed to read from parcel, error=%d", res);
770 return nullptr;
771 }
772 return BufferHubProducer::Create(std::move(producerParcelable));
773 #else
774 return nullptr;
775 #endif
776 }
777 default: {
778 ALOGE("createFromParcel: Unexpected mgaic: 0x%x.", outMagic);
779 return nullptr;
780 }
781 }
782 }
783
784 // ----------------------------------------------------------------------------
785
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)786 status_t BnGraphicBufferProducer::onTransact(
787 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
788 {
789 switch(code) {
790 case REQUEST_BUFFER: {
791 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
792 int bufferIdx = data.readInt32();
793 sp<GraphicBuffer> buffer;
794 int result = requestBuffer(bufferIdx, &buffer);
795 reply->writeInt32(buffer != nullptr);
796 if (buffer != nullptr) {
797 reply->write(*buffer);
798 }
799 reply->writeInt32(result);
800 return NO_ERROR;
801 }
802 case SET_MAX_DEQUEUED_BUFFER_COUNT: {
803 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
804 int maxDequeuedBuffers = data.readInt32();
805 int result = setMaxDequeuedBufferCount(maxDequeuedBuffers);
806 reply->writeInt32(result);
807 return NO_ERROR;
808 }
809 case SET_ASYNC_MODE: {
810 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
811 bool async = data.readInt32();
812 int result = setAsyncMode(async);
813 reply->writeInt32(result);
814 return NO_ERROR;
815 }
816 case DEQUEUE_BUFFER: {
817 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
818 uint32_t width = data.readUint32();
819 uint32_t height = data.readUint32();
820 PixelFormat format = static_cast<PixelFormat>(data.readInt32());
821 uint64_t usage = data.readUint64();
822 uint64_t bufferAge = 0;
823 bool getTimestamps = data.readBool();
824
825 int buf = 0;
826 sp<Fence> fence = Fence::NO_FENCE;
827 FrameEventHistoryDelta frameTimestamps;
828 int result = dequeueBuffer(&buf, &fence, width, height, format, usage, &bufferAge,
829 getTimestamps ? &frameTimestamps : nullptr);
830
831 if (fence == nullptr) {
832 ALOGE("dequeueBuffer returned a NULL fence, setting to Fence::NO_FENCE");
833 fence = Fence::NO_FENCE;
834 }
835 reply->writeInt32(buf);
836 reply->write(*fence);
837 reply->writeUint64(bufferAge);
838 if (getTimestamps) {
839 reply->write(frameTimestamps);
840 }
841 reply->writeInt32(result);
842 return NO_ERROR;
843 }
844 case DETACH_BUFFER: {
845 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
846 int slot = data.readInt32();
847 int result = detachBuffer(slot);
848 reply->writeInt32(result);
849 return NO_ERROR;
850 }
851 case DETACH_NEXT_BUFFER: {
852 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
853 sp<GraphicBuffer> buffer;
854 sp<Fence> fence;
855 int32_t result = detachNextBuffer(&buffer, &fence);
856 reply->writeInt32(result);
857 if (result == NO_ERROR) {
858 reply->writeInt32(buffer != nullptr);
859 if (buffer != nullptr) {
860 reply->write(*buffer);
861 }
862 reply->writeInt32(fence != nullptr);
863 if (fence != nullptr) {
864 reply->write(*fence);
865 }
866 }
867 return NO_ERROR;
868 }
869 case ATTACH_BUFFER: {
870 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
871 sp<GraphicBuffer> buffer = new GraphicBuffer();
872 status_t result = data.read(*buffer.get());
873 int slot = 0;
874 if (result == NO_ERROR) {
875 result = attachBuffer(&slot, buffer);
876 }
877 reply->writeInt32(slot);
878 reply->writeInt32(result);
879 return NO_ERROR;
880 }
881 case QUEUE_BUFFER: {
882 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
883
884 int buf = data.readInt32();
885 QueueBufferInput input(data);
886 QueueBufferOutput output;
887 status_t result = queueBuffer(buf, input, &output);
888 reply->write(output);
889 reply->writeInt32(result);
890
891 return NO_ERROR;
892 }
893 case CANCEL_BUFFER: {
894 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
895 int buf = data.readInt32();
896 sp<Fence> fence = new Fence();
897 status_t result = data.read(*fence.get());
898 if (result == NO_ERROR) {
899 result = cancelBuffer(buf, fence);
900 }
901 reply->writeInt32(result);
902 return NO_ERROR;
903 }
904 case QUERY: {
905 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
906 int value = 0;
907 int what = data.readInt32();
908 int res = query(what, &value);
909 reply->writeInt32(value);
910 reply->writeInt32(res);
911 return NO_ERROR;
912 }
913 case CONNECT: {
914 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
915 sp<IProducerListener> listener;
916 if (data.readInt32() == 1) {
917 listener = IProducerListener::asInterface(data.readStrongBinder());
918 }
919 int api = data.readInt32();
920 bool producerControlledByApp = data.readInt32();
921 QueueBufferOutput output;
922 status_t res = connect(listener, api, producerControlledByApp, &output);
923 reply->write(output);
924 reply->writeInt32(res);
925 return NO_ERROR;
926 }
927 case DISCONNECT: {
928 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
929 int api = data.readInt32();
930 DisconnectMode mode = static_cast<DisconnectMode>(data.readInt32());
931 status_t res = disconnect(api, mode);
932 reply->writeInt32(res);
933 return NO_ERROR;
934 }
935 case SET_SIDEBAND_STREAM: {
936 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
937 sp<NativeHandle> stream;
938 if (data.readInt32()) {
939 stream = NativeHandle::create(data.readNativeHandle(), true);
940 }
941 status_t result = setSidebandStream(stream);
942 reply->writeInt32(result);
943 return NO_ERROR;
944 }
945 case ALLOCATE_BUFFERS: {
946 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
947 uint32_t width = data.readUint32();
948 uint32_t height = data.readUint32();
949 PixelFormat format = static_cast<PixelFormat>(data.readInt32());
950 uint64_t usage = data.readUint64();
951 allocateBuffers(width, height, format, usage);
952 return NO_ERROR;
953 }
954 case ALLOW_ALLOCATION: {
955 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
956 bool allow = static_cast<bool>(data.readInt32());
957 status_t result = allowAllocation(allow);
958 reply->writeInt32(result);
959 return NO_ERROR;
960 }
961 case SET_GENERATION_NUMBER: {
962 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
963 uint32_t generationNumber = data.readUint32();
964 status_t result = setGenerationNumber(generationNumber);
965 reply->writeInt32(result);
966 return NO_ERROR;
967 }
968 case GET_CONSUMER_NAME: {
969 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
970 reply->writeString8(getConsumerName());
971 return NO_ERROR;
972 }
973 case SET_SHARED_BUFFER_MODE: {
974 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
975 bool sharedBufferMode = data.readInt32();
976 status_t result = setSharedBufferMode(sharedBufferMode);
977 reply->writeInt32(result);
978 return NO_ERROR;
979 }
980 case SET_AUTO_REFRESH: {
981 CHECK_INTERFACE(IGraphicBuffer, data, reply);
982 bool autoRefresh = data.readInt32();
983 status_t result = setAutoRefresh(autoRefresh);
984 reply->writeInt32(result);
985 return NO_ERROR;
986 }
987 case SET_DEQUEUE_TIMEOUT: {
988 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
989 nsecs_t timeout = data.readInt64();
990 status_t result = setDequeueTimeout(timeout);
991 reply->writeInt32(result);
992 return NO_ERROR;
993 }
994 case GET_LAST_QUEUED_BUFFER: {
995 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
996 sp<GraphicBuffer> buffer(nullptr);
997 sp<Fence> fence(Fence::NO_FENCE);
998 float transform[16] = {};
999 status_t result = getLastQueuedBuffer(&buffer, &fence, transform);
1000 reply->writeInt32(result);
1001 if (result != NO_ERROR) {
1002 return result;
1003 }
1004 if (!buffer.get()) {
1005 reply->writeBool(false);
1006 } else {
1007 reply->writeBool(true);
1008 result = reply->write(*buffer);
1009 if (result == NO_ERROR) {
1010 reply->write(transform, sizeof(float) * 16);
1011 }
1012 }
1013 if (result != NO_ERROR) {
1014 ALOGE("getLastQueuedBuffer failed to write buffer: %d", result);
1015 return result;
1016 }
1017 if (fence == nullptr) {
1018 ALOGE("getLastQueuedBuffer returned a NULL fence, setting to Fence::NO_FENCE");
1019 fence = Fence::NO_FENCE;
1020 }
1021 result = reply->write(*fence);
1022 if (result != NO_ERROR) {
1023 ALOGE("getLastQueuedBuffer failed to write fence: %d", result);
1024 return result;
1025 }
1026 return NO_ERROR;
1027 }
1028 case GET_FRAME_TIMESTAMPS: {
1029 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
1030 FrameEventHistoryDelta frameTimestamps;
1031 getFrameTimestamps(&frameTimestamps);
1032 status_t result = reply->write(frameTimestamps);
1033 if (result != NO_ERROR) {
1034 ALOGE("BnGBP::GET_FRAME_TIMESTAMPS failed to write buffer: %d",
1035 result);
1036 return result;
1037 }
1038 return NO_ERROR;
1039 }
1040 case GET_UNIQUE_ID: {
1041 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
1042 uint64_t outId = 0;
1043 status_t actualResult = getUniqueId(&outId);
1044 status_t result = reply->writeInt32(actualResult);
1045 if (result != NO_ERROR) {
1046 return result;
1047 }
1048 result = reply->writeUint64(outId);
1049 if (result != NO_ERROR) {
1050 return result;
1051 }
1052 return NO_ERROR;
1053 }
1054 case GET_CONSUMER_USAGE: {
1055 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
1056 uint64_t outUsage = 0;
1057 status_t actualResult = getConsumerUsage(&outUsage);
1058 status_t result = reply->writeInt32(actualResult);
1059 if (result != NO_ERROR) {
1060 return result;
1061 }
1062 result = reply->writeUint64(outUsage);
1063 if (result != NO_ERROR) {
1064 return result;
1065 }
1066 return NO_ERROR;
1067 }
1068 case SET_LEGACY_BUFFER_DROP: {
1069 CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
1070 bool drop = data.readInt32();
1071 int result = setLegacyBufferDrop(drop);
1072 reply->writeInt32(result);
1073 return NO_ERROR;
1074 }
1075 case SET_AUTO_PREROTATION: {
1076 CHECK_INTERFACE(IGraphicBuffer, data, reply);
1077 bool autoPrerotation = data.readBool();
1078 status_t result = setAutoPrerotation(autoPrerotation);
1079 reply->writeInt32(result);
1080 return NO_ERROR;
1081 }
1082 }
1083 return BBinder::onTransact(code, data, reply, flags);
1084 }
1085
1086 // ----------------------------------------------------------------------------
1087
QueueBufferInput(const Parcel & parcel)1088 IGraphicBufferProducer::QueueBufferInput::QueueBufferInput(const Parcel& parcel) {
1089 parcel.read(*this);
1090 }
1091
1092
1093 }; // namespace android
1094