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