libs/gui/IGraphicBufferProducer.cpp

   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