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