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/Timers.h>
  24 #include <utils/Vector.h>
  25
  26 #include <binder/Parcel.h>
  27 #include <binder/IInterface.h>
  28
  29 #include <gui/IGraphicBufferProducer.h>
  30 #include <gui/IProducerListener.h>
  31
  32 namespace android {
  33 // ----------------------------------------------------------------------------
  34
  35 enum {
  36     REQUEST_BUFFER = IBinder::FIRST_CALL_TRANSACTION,
  37     DEQUEUE_BUFFER,
  38     DETACH_BUFFER,
  39     DETACH_NEXT_BUFFER,
  40     ATTACH_BUFFER,
  41     QUEUE_BUFFER,
  42     CANCEL_BUFFER,
  43     QUERY,
  44     CONNECT,
  45     DISCONNECT,
  46     SET_SIDEBAND_STREAM,
  47     ALLOCATE_BUFFERS,
  48     ALLOW_ALLOCATION,
  49     SET_GENERATION_NUMBER,
  50     GET_CONSUMER_NAME,
  51     SET_MAX_DEQUEUED_BUFFER_COUNT,
  52     SET_ASYNC_MODE,
  53     SET_SHARED_BUFFER_MODE,
  54     SET_AUTO_REFRESH,
  55     SET_DEQUEUE_TIMEOUT,
  56     GET_LAST_QUEUED_BUFFER,
  57     GET_FRAME_TIMESTAMPS,
  58     GET_UNIQUE_ID
  59 };
  60
  61 class BpGraphicBufferProducer : public BpInterface<IGraphicBufferProducer>
  62 {
  63 public:
  64     BpGraphicBufferProducer(const sp<IBinder>& impl)
  65         : BpInterface<IGraphicBufferProducer>(impl)
  66     {
  67     }
  68
  69     virtual ~BpGraphicBufferProducer();
  70
  71     virtual status_t requestBuffer(int bufferIdx, sp<GraphicBuffer>* buf) {
  72         Parcel data, reply;
  73         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
  74         data.writeInt32(bufferIdx);
  75         status_t result =remote()->transact(REQUEST_BUFFER, data, &reply);
  76         if (result != NO_ERROR) {
  77             return result;
  78         }
  79         bool nonNull = reply.readInt32();
  80         if (nonNull) {
  81             *buf = new GraphicBuffer();
  82             result = reply.read(**buf);
  83             if(result != NO_ERROR) {
  84                 (*buf).clear();
  85                 return result;
  86             }
  87         }
  88         result = reply.readInt32();
  89         return result;
  90     }
  91
  92     virtual status_t setMaxDequeuedBufferCount(int maxDequeuedBuffers) {
  93         Parcel data, reply;
  94         data.writeInterfaceToken(
  95                 IGraphicBufferProducer::getInterfaceDescriptor());
  96         data.writeInt32(maxDequeuedBuffers);
  97         status_t result = remote()->transact(SET_MAX_DEQUEUED_BUFFER_COUNT,
  98                 data, &reply);
  99         if (result != NO_ERROR) {
 100             return result;
 101         }
 102         result = reply.readInt32();
 103         return result;
 104     }
 105
 106     virtual status_t setAsyncMode(bool async) {
 107         Parcel data, reply;
 108         data.writeInterfaceToken(
 109                 IGraphicBufferProducer::getInterfaceDescriptor());
 110         data.writeInt32(async);
 111         status_t result = remote()->transact(SET_ASYNC_MODE,
 112                 data, &reply);
 113         if (result != NO_ERROR) {
 114             return result;
 115         }
 116         result = reply.readInt32();
 117         return result;
 118     }
 119
 120     virtual status_t dequeueBuffer(int *buf, sp<Fence>* fence, uint32_t width,
 121             uint32_t height, PixelFormat format, uint32_t usage) {
 122         Parcel data, reply;
 123         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 124         data.writeUint32(width);
 125         data.writeUint32(height);
 126         data.writeInt32(static_cast<int32_t>(format));
 127         data.writeUint32(usage);
 128         status_t result = remote()->transact(DEQUEUE_BUFFER, data, &reply);
 129         if (result != NO_ERROR) {
 130             return result;
 131         }
 132         *buf = reply.readInt32();
 133         bool nonNull = reply.readInt32();
 134         if (nonNull) {
 135             *fence = new Fence();
 136             result = reply.read(**fence);
 137             if (result != NO_ERROR) {
 138                 fence->clear();
 139                 return result;
 140             }
 141         }
 142         result = reply.readInt32();
 143         return result;
 144     }
 145
 146     virtual status_t detachBuffer(int slot) {
 147         Parcel data, reply;
 148         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 149         data.writeInt32(slot);
 150         status_t result = remote()->transact(DETACH_BUFFER, data, &reply);
 151         if (result != NO_ERROR) {
 152             return result;
 153         }
 154         result = reply.readInt32();
 155         return result;
 156     }
 157
 158     virtual status_t detachNextBuffer(sp<GraphicBuffer>* outBuffer,
 159             sp<Fence>* outFence) {
 160         if (outBuffer == NULL) {
 161             ALOGE("detachNextBuffer: outBuffer must not be NULL");
 162             return BAD_VALUE;
 163         } else if (outFence == NULL) {
 164             ALOGE("detachNextBuffer: outFence must not be NULL");
 165             return BAD_VALUE;
 166         }
 167         Parcel data, reply;
 168         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 169         status_t result = remote()->transact(DETACH_NEXT_BUFFER, data, &reply);
 170         if (result != NO_ERROR) {
 171             return result;
 172         }
 173         result = reply.readInt32();
 174         if (result == NO_ERROR) {
 175             bool nonNull = reply.readInt32();
 176             if (nonNull) {
 177                 *outBuffer = new GraphicBuffer;
 178                 result = reply.read(**outBuffer);
 179                 if (result != NO_ERROR) {
 180                     outBuffer->clear();
 181                     return result;
 182                 }
 183             }
 184             nonNull = reply.readInt32();
 185             if (nonNull) {
 186                 *outFence = new Fence;
 187                 result = reply.read(**outFence);
 188                 if (result != NO_ERROR) {
 189                     outBuffer->clear();
 190                     outFence->clear();
 191                     return result;
 192                 }
 193             }
 194         }
 195         return result;
 196     }
 197
 198     virtual status_t attachBuffer(int* slot, const sp<GraphicBuffer>& buffer) {
 199         Parcel data, reply;
 200         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 201         data.write(*buffer.get());
 202         status_t result = remote()->transact(ATTACH_BUFFER, data, &reply);
 203         if (result != NO_ERROR) {
 204             return result;
 205         }
 206         *slot = reply.readInt32();
 207         result = reply.readInt32();
 208         return result;
 209     }
 210
 211     virtual status_t queueBuffer(int buf,
 212             const QueueBufferInput& input, QueueBufferOutput* output) {
 213         Parcel data, reply;
 214         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 215         data.writeInt32(buf);
 216         data.write(input);
 217         status_t result = remote()->transact(QUEUE_BUFFER, data, &reply);
 218         if (result != NO_ERROR) {
 219             return result;
 220         }
 221         memcpy(output, reply.readInplace(sizeof(*output)), sizeof(*output));
 222         result = reply.readInt32();
 223         return result;
 224     }
 225
 226     virtual status_t cancelBuffer(int buf, const sp<Fence>& fence) {
 227         Parcel data, reply;
 228         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 229         data.writeInt32(buf);
 230         data.write(*fence.get());
 231         status_t result = remote()->transact(CANCEL_BUFFER, data, &reply);
 232         if (result != NO_ERROR) {
 233             return result;
 234         }
 235         result = reply.readInt32();
 236         return result;
 237     }
 238
 239     virtual int query(int what, int* value) {
 240         Parcel data, reply;
 241         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 242         data.writeInt32(what);
 243         status_t result = remote()->transact(QUERY, data, &reply);
 244         if (result != NO_ERROR) {
 245             return result;
 246         }
 247         value[0] = reply.readInt32();
 248         result = reply.readInt32();
 249         return result;
 250     }
 251
 252     virtual status_t connect(const sp<IProducerListener>& listener,
 253             int api, bool producerControlledByApp, QueueBufferOutput* output) {
 254         Parcel data, reply;
 255         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 256         if (listener != NULL) {
 257             data.writeInt32(1);
 258             data.writeStrongBinder(IInterface::asBinder(listener));
 259         } else {
 260             data.writeInt32(0);
 261         }
 262         data.writeInt32(api);
 263         data.writeInt32(producerControlledByApp);
 264         status_t result = remote()->transact(CONNECT, data, &reply);
 265         if (result != NO_ERROR) {
 266             return result;
 267         }
 268         memcpy(output, reply.readInplace(sizeof(*output)), sizeof(*output));
 269         result = reply.readInt32();
 270         return result;
 271     }
 272
 273     virtual status_t disconnect(int api, DisconnectMode mode) {
 274         Parcel data, reply;
 275         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 276         data.writeInt32(api);
 277         data.writeInt32(static_cast<int32_t>(mode));
 278         status_t result =remote()->transact(DISCONNECT, data, &reply);
 279         if (result != NO_ERROR) {
 280             return result;
 281         }
 282         result = reply.readInt32();
 283         return result;
 284     }
 285
 286     virtual status_t setSidebandStream(const sp<NativeHandle>& stream) {
 287         Parcel data, reply;
 288         status_t result;
 289         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 290         if (stream.get()) {
 291             data.writeInt32(true);
 292             data.writeNativeHandle(stream->handle());
 293         } else {
 294             data.writeInt32(false);
 295         }
 296         if ((result = remote()->transact(SET_SIDEBAND_STREAM, data, &reply)) == NO_ERROR) {
 297             result = reply.readInt32();
 298         }
 299         return result;
 300     }
 301
 302     virtual void allocateBuffers(uint32_t width, uint32_t height,
 303             PixelFormat format, uint32_t usage) {
 304         Parcel data, reply;
 305         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 306         data.writeUint32(width);
 307         data.writeUint32(height);
 308         data.writeInt32(static_cast<int32_t>(format));
 309         data.writeUint32(usage);
 310         status_t result = remote()->transact(ALLOCATE_BUFFERS, data, &reply);
 311         if (result != NO_ERROR) {
 312             ALOGE("allocateBuffers failed to transact: %d", result);
 313         }
 314     }
 315
 316     virtual status_t allowAllocation(bool allow) {
 317         Parcel data, reply;
 318         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 319         data.writeInt32(static_cast<int32_t>(allow));
 320         status_t result = remote()->transact(ALLOW_ALLOCATION, data, &reply);
 321         if (result != NO_ERROR) {
 322             return result;
 323         }
 324         result = reply.readInt32();
 325         return result;
 326     }
 327
 328     virtual status_t setGenerationNumber(uint32_t generationNumber) {
 329         Parcel data, reply;
 330         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 331         data.writeUint32(generationNumber);
 332         status_t result = remote()->transact(SET_GENERATION_NUMBER, data, &reply);
 333         if (result == NO_ERROR) {
 334             result = reply.readInt32();
 335         }
 336         return result;
 337     }
 338
 339     virtual String8 getConsumerName() const {
 340         Parcel data, reply;
 341         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 342         status_t result = remote()->transact(GET_CONSUMER_NAME, data, &reply);
 343         if (result != NO_ERROR) {
 344             ALOGE("getConsumerName failed to transact: %d", result);
 345             return String8("TransactFailed");
 346         }
 347         return reply.readString8();
 348     }
 349
 350     virtual status_t setSharedBufferMode(bool sharedBufferMode) {
 351         Parcel data, reply;
 352         data.writeInterfaceToken(
 353                 IGraphicBufferProducer::getInterfaceDescriptor());
 354         data.writeInt32(sharedBufferMode);
 355         status_t result = remote()->transact(SET_SHARED_BUFFER_MODE, data,
 356                 &reply);
 357         if (result == NO_ERROR) {
 358             result = reply.readInt32();
 359         }
 360         return result;
 361     }
 362
 363     virtual status_t setAutoRefresh(bool autoRefresh) {
 364         Parcel data, reply;
 365         data.writeInterfaceToken(
 366                 IGraphicBufferProducer::getInterfaceDescriptor());
 367         data.writeInt32(autoRefresh);
 368         status_t result = remote()->transact(SET_AUTO_REFRESH, data, &reply);
 369         if (result == NO_ERROR) {
 370             result = reply.readInt32();
 371         }
 372         return result;
 373     }
 374
 375     virtual status_t setDequeueTimeout(nsecs_t timeout) {
 376         Parcel data, reply;
 377         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 378         data.writeInt64(timeout);
 379         status_t result = remote()->transact(SET_DEQUEUE_TIMEOUT, data, &reply);
 380         if (result != NO_ERROR) {
 381             ALOGE("setDequeueTimeout failed to transact: %d", result);
 382             return result;
 383         }
 384         return reply.readInt32();
 385     }
 386
 387     virtual status_t getLastQueuedBuffer(sp<GraphicBuffer>* outBuffer,
 388             sp<Fence>* outFence, float outTransformMatrix[16]) override {
 389         Parcel data, reply;
 390         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 391         status_t result = remote()->transact(GET_LAST_QUEUED_BUFFER, data,
 392                 &reply);
 393         if (result != NO_ERROR) {
 394             ALOGE("getLastQueuedBuffer failed to transact: %d", result);
 395             return result;
 396         }
 397         result = reply.readInt32();
 398         if (result != NO_ERROR) {
 399             return result;
 400         }
 401         bool hasBuffer = reply.readBool();
 402         sp<GraphicBuffer> buffer;
 403         if (hasBuffer) {
 404             buffer = new GraphicBuffer();
 405             result = reply.read(*buffer);
 406             if (result == NO_ERROR) {
 407                 result = reply.read(outTransformMatrix, sizeof(float) * 16);
 408             }
 409         }
 410         if (result != NO_ERROR) {
 411             ALOGE("getLastQueuedBuffer failed to read buffer: %d", result);
 412             return result;
 413         }
 414         sp<Fence> fence(new Fence);
 415         result = reply.read(*fence);
 416         if (result != NO_ERROR) {
 417             ALOGE("getLastQueuedBuffer failed to read fence: %d", result);
 418             return result;
 419         }
 420         *outBuffer = buffer;
 421         *outFence = fence;
 422         return result;
 423     }
 424
 425     virtual bool getFrameTimestamps(uint64_t frameNumber,
 426                 FrameTimestamps* outTimestamps) const {
 427         Parcel data, reply;
 428         status_t result = data.writeInterfaceToken(
 429                 IGraphicBufferProducer::getInterfaceDescriptor());
 430         if (result != NO_ERROR) {
 431             ALOGE("getFrameTimestamps failed to write token: %d", result);
 432             return false;
 433         }
 434         result = data.writeUint64(frameNumber);
 435         if (result != NO_ERROR) {
 436             ALOGE("getFrameTimestamps failed to write: %d", result);
 437             return false;
 438         }
 439         result = remote()->transact(GET_FRAME_TIMESTAMPS, data, &reply);
 440         if (result != NO_ERROR) {
 441             ALOGE("getFrameTimestamps failed to transact: %d", result);
 442             return false;
 443         }
 444         bool found = false;
 445         result = reply.readBool(&found);
 446         if (result != NO_ERROR) {
 447             ALOGE("getFrameTimestamps failed to read: %d", result);
 448             return false;
 449         }
 450         if (found) {
 451             result = reply.read(*outTimestamps);
 452             if (result != NO_ERROR) {
 453                 ALOGE("getFrameTimestamps failed to read timestamps: %d",
 454                         result);
 455                 return false;
 456             }
 457         }
 458         return found;
 459     }
 460
 461     virtual status_t getUniqueId(uint64_t* outId) const {
 462         Parcel data, reply;
 463         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 464         status_t result = remote()->transact(GET_UNIQUE_ID, data, &reply);
 465         if (result != NO_ERROR) {
 466             ALOGE("getUniqueId failed to transact: %d", result);
 467         }
 468         status_t actualResult = NO_ERROR;
 469         result = reply.readInt32(&actualResult);
 470         if (result != NO_ERROR) {
 471             return result;
 472         }
 473         result = reply.readUint64(outId);
 474         if (result != NO_ERROR) {
 475             return result;
 476         }
 477         return actualResult;
 478     }
 479 };
 480
 481 // Out-of-line virtual method definition to trigger vtable emission in this
 482 // translation unit (see clang warning -Wweak-vtables)
 483 BpGraphicBufferProducer::~BpGraphicBufferProducer() {}
 484
 485 IMPLEMENT_META_INTERFACE(GraphicBufferProducer, "android.gui.IGraphicBufferProducer");
 486
 487 // ----------------------------------------------------------------------
 488
 489 status_t BnGraphicBufferProducer::onTransact(
 490     uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
 491 {
 492     switch(code) {
 493         case REQUEST_BUFFER: {
 494             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 495             int bufferIdx   = data.readInt32();
 496             sp<GraphicBuffer> buffer;
 497             int result = requestBuffer(bufferIdx, &buffer);
 498             reply->writeInt32(buffer != 0);
 499             if (buffer != 0) {
 500                 reply->write(*buffer);
 501             }
 502             reply->writeInt32(result);
 503             return NO_ERROR;
 504         }
 505         case SET_MAX_DEQUEUED_BUFFER_COUNT: {
 506             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 507             int maxDequeuedBuffers = data.readInt32();
 508             int result = setMaxDequeuedBufferCount(maxDequeuedBuffers);
 509             reply->writeInt32(result);
 510             return NO_ERROR;
 511         }
 512         case SET_ASYNC_MODE: {
 513             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 514             bool async = data.readInt32();
 515             int result = setAsyncMode(async);
 516             reply->writeInt32(result);
 517             return NO_ERROR;
 518         }
 519         case DEQUEUE_BUFFER: {
 520             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 521             uint32_t width = data.readUint32();
 522             uint32_t height = data.readUint32();
 523             PixelFormat format = static_cast<PixelFormat>(data.readInt32());
 524             uint32_t usage = data.readUint32();
 525             int buf = 0;
 526             sp<Fence> fence;
 527             int result = dequeueBuffer(&buf, &fence, width, height, format,
 528                     usage);
 529             reply->writeInt32(buf);
 530             reply->writeInt32(fence != NULL);
 531             if (fence != NULL) {
 532                 reply->write(*fence);
 533             }
 534             reply->writeInt32(result);
 535             return NO_ERROR;
 536         }
 537         case DETACH_BUFFER: {
 538             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 539             int slot = data.readInt32();
 540             int result = detachBuffer(slot);
 541             reply->writeInt32(result);
 542             return NO_ERROR;
 543         }
 544         case DETACH_NEXT_BUFFER: {
 545             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 546             sp<GraphicBuffer> buffer;
 547             sp<Fence> fence;
 548             int32_t result = detachNextBuffer(&buffer, &fence);
 549             reply->writeInt32(result);
 550             if (result == NO_ERROR) {
 551                 reply->writeInt32(buffer != NULL);
 552                 if (buffer != NULL) {
 553                     reply->write(*buffer);
 554                 }
 555                 reply->writeInt32(fence != NULL);
 556                 if (fence != NULL) {
 557                     reply->write(*fence);
 558                 }
 559             }
 560             return NO_ERROR;
 561         }
 562         case ATTACH_BUFFER: {
 563             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 564             sp<GraphicBuffer> buffer = new GraphicBuffer();
 565             status_t result = data.read(*buffer.get());
 566             int slot = 0;
 567             if (result == NO_ERROR) {
 568                 result = attachBuffer(&slot, buffer);
 569             }
 570             reply->writeInt32(slot);
 571             reply->writeInt32(result);
 572             return NO_ERROR;
 573         }
 574         case QUEUE_BUFFER: {
 575             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 576             int buf = data.readInt32();
 577             QueueBufferInput input(data);
 578             QueueBufferOutput* const output =
 579                     reinterpret_cast<QueueBufferOutput *>(
 580                             reply->writeInplace(sizeof(QueueBufferOutput)));
 581             memset(output, 0, sizeof(QueueBufferOutput));
 582             status_t result = queueBuffer(buf, input, output);
 583             reply->writeInt32(result);
 584             return NO_ERROR;
 585         }
 586         case CANCEL_BUFFER: {
 587             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 588             int buf = data.readInt32();
 589             sp<Fence> fence = new Fence();
 590             status_t result = data.read(*fence.get());
 591             if (result == NO_ERROR) {
 592                 result = cancelBuffer(buf, fence);
 593             }
 594             reply->writeInt32(result);
 595             return NO_ERROR;
 596         }
 597         case QUERY: {
 598             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 599             int value = 0;
 600             int what = data.readInt32();
 601             int res = query(what, &value);
 602             reply->writeInt32(value);
 603             reply->writeInt32(res);
 604             return NO_ERROR;
 605         }
 606         case CONNECT: {
 607             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 608             sp<IProducerListener> listener;
 609             if (data.readInt32() == 1) {
 610                 listener = IProducerListener::asInterface(data.readStrongBinder());
 611             }
 612             int api = data.readInt32();
 613             bool producerControlledByApp = data.readInt32();
 614             QueueBufferOutput* const output =
 615                     reinterpret_cast<QueueBufferOutput *>(
 616                             reply->writeInplace(sizeof(QueueBufferOutput)));
 617             memset(output, 0, sizeof(QueueBufferOutput));
 618             status_t res = connect(listener, api, producerControlledByApp, output);
 619             reply->writeInt32(res);
 620             return NO_ERROR;
 621         }
 622         case DISCONNECT: {
 623             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 624             int api = data.readInt32();
 625             DisconnectMode mode = static_cast<DisconnectMode>(data.readInt32());
 626             status_t res = disconnect(api, mode);
 627             reply->writeInt32(res);
 628             return NO_ERROR;
 629         }
 630         case SET_SIDEBAND_STREAM: {
 631             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 632             sp<NativeHandle> stream;
 633             if (data.readInt32()) {
 634                 stream = NativeHandle::create(data.readNativeHandle(), true);
 635             }
 636             status_t result = setSidebandStream(stream);
 637             reply->writeInt32(result);
 638             return NO_ERROR;
 639         }
 640         case ALLOCATE_BUFFERS: {
 641             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 642             uint32_t width = data.readUint32();
 643             uint32_t height = data.readUint32();
 644             PixelFormat format = static_cast<PixelFormat>(data.readInt32());
 645             uint32_t usage = data.readUint32();
 646             allocateBuffers(width, height, format, usage);
 647             return NO_ERROR;
 648         }
 649         case ALLOW_ALLOCATION: {
 650             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 651             bool allow = static_cast<bool>(data.readInt32());
 652             status_t result = allowAllocation(allow);
 653             reply->writeInt32(result);
 654             return NO_ERROR;
 655         }
 656         case SET_GENERATION_NUMBER: {
 657             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 658             uint32_t generationNumber = data.readUint32();
 659             status_t result = setGenerationNumber(generationNumber);
 660             reply->writeInt32(result);
 661             return NO_ERROR;
 662         }
 663         case GET_CONSUMER_NAME: {
 664             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 665             reply->writeString8(getConsumerName());
 666             return NO_ERROR;
 667         }
 668         case SET_SHARED_BUFFER_MODE: {
 669             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 670             bool sharedBufferMode = data.readInt32();
 671             status_t result = setSharedBufferMode(sharedBufferMode);
 672             reply->writeInt32(result);
 673             return NO_ERROR;
 674         }
 675         case SET_AUTO_REFRESH: {
 676             CHECK_INTERFACE(IGraphicBuffer, data, reply);
 677             bool autoRefresh = data.readInt32();
 678             status_t result = setAutoRefresh(autoRefresh);
 679             reply->writeInt32(result);
 680             return NO_ERROR;
 681         }
 682         case SET_DEQUEUE_TIMEOUT: {
 683             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 684             nsecs_t timeout = data.readInt64();
 685             status_t result = setDequeueTimeout(timeout);
 686             reply->writeInt32(result);
 687             return NO_ERROR;
 688         }
 689         case GET_LAST_QUEUED_BUFFER: {
 690             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 691             sp<GraphicBuffer> buffer(nullptr);
 692             sp<Fence> fence(Fence::NO_FENCE);
 693             float transform[16] = {};
 694             status_t result = getLastQueuedBuffer(&buffer, &fence, transform);
 695             reply->writeInt32(result);
 696             if (result != NO_ERROR) {
 697                 return result;
 698             }
 699             if (!buffer.get()) {
 700                 reply->writeBool(false);
 701             } else {
 702                 reply->writeBool(true);
 703                 result = reply->write(*buffer);
 704                 if (result == NO_ERROR) {
 705                     reply->write(transform, sizeof(float) * 16);
 706                 }
 707             }
 708             if (result != NO_ERROR) {
 709                 ALOGE("getLastQueuedBuffer failed to write buffer: %d", result);
 710                 return result;
 711             }
 712             result = reply->write(*fence);
 713             if (result != NO_ERROR) {
 714                 ALOGE("getLastQueuedBuffer failed to write fence: %d", result);
 715                 return result;
 716             }
 717             return NO_ERROR;
 718         }
 719         case GET_FRAME_TIMESTAMPS: {
 720             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 721             uint64_t frameNumber = 0;
 722             status_t result = data.readUint64(&frameNumber);
 723             if (result != NO_ERROR) {
 724                 ALOGE("onTransact failed to read: %d", result);
 725                 return result;
 726             }
 727             FrameTimestamps timestamps;
 728             bool found = getFrameTimestamps(frameNumber, &timestamps);
 729             result = reply->writeBool(found);
 730             if (result != NO_ERROR) {
 731                 ALOGE("onTransact failed to write: %d", result);
 732                 return result;
 733             }
 734             if (found) {
 735                 result = reply->write(timestamps);
 736                 if (result != NO_ERROR) {
 737                     ALOGE("onTransact failed to write timestamps: %d", result);
 738                     return result;
 739                 }
 740             }
 741             return NO_ERROR;
 742         }
 743         case GET_UNIQUE_ID: {
 744             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 745             uint64_t outId = 0;
 746             status_t actualResult = getUniqueId(&outId);
 747             status_t result = reply->writeInt32(actualResult);
 748             if (result != NO_ERROR) {
 749                 return result;
 750             }
 751             result = reply->writeUint64(outId);
 752             if (result != NO_ERROR) {
 753                 return result;
 754             }
 755             return NO_ERROR;
 756         }
 757     }
 758     return BBinder::onTransact(code, data, reply, flags);
 759 }
 760
 761 // ----------------------------------------------------------------------------
 762
 763 IGraphicBufferProducer::QueueBufferInput::QueueBufferInput(const Parcel& parcel) {
 764     parcel.read(*this);
 765 }
 766
 767 size_t IGraphicBufferProducer::QueueBufferInput::getFlattenedSize() const {
 768     return sizeof(timestamp)
 769          + sizeof(isAutoTimestamp)
 770          + sizeof(dataSpace)
 771          + sizeof(crop)
 772          + sizeof(scalingMode)
 773          + sizeof(transform)
 774          + sizeof(stickyTransform)
 775          + fence->getFlattenedSize()
 776          + surfaceDamage.getFlattenedSize();
 777 }
 778
 779 size_t IGraphicBufferProducer::QueueBufferInput::getFdCount() const {
 780     return fence->getFdCount();
 781 }
 782
 783 status_t IGraphicBufferProducer::QueueBufferInput::flatten(
 784         void*& buffer, size_t& size, int*& fds, size_t& count) const
 785 {
 786     if (size < getFlattenedSize()) {
 787         return NO_MEMORY;
 788     }
 789     FlattenableUtils::write(buffer, size, timestamp);
 790     FlattenableUtils::write(buffer, size, isAutoTimestamp);
 791     FlattenableUtils::write(buffer, size, dataSpace);
 792     FlattenableUtils::write(buffer, size, crop);
 793     FlattenableUtils::write(buffer, size, scalingMode);
 794     FlattenableUtils::write(buffer, size, transform);
 795     FlattenableUtils::write(buffer, size, stickyTransform);
 796     status_t result = fence->flatten(buffer, size, fds, count);
 797     if (result != NO_ERROR) {
 798         return result;
 799     }
 800     return surfaceDamage.flatten(buffer, size);
 801 }
 802
 803 status_t IGraphicBufferProducer::QueueBufferInput::unflatten(
 804         void const*& buffer, size_t& size, int const*& fds, size_t& count)
 805 {
 806     size_t minNeeded =
 807               sizeof(timestamp)
 808             + sizeof(isAutoTimestamp)
 809             + sizeof(dataSpace)
 810             + sizeof(crop)
 811             + sizeof(scalingMode)
 812             + sizeof(transform)
 813             + sizeof(stickyTransform);
 814
 815     if (size < minNeeded) {
 816         return NO_MEMORY;
 817     }
 818
 819     FlattenableUtils::read(buffer, size, timestamp);
 820     FlattenableUtils::read(buffer, size, isAutoTimestamp);
 821     FlattenableUtils::read(buffer, size, dataSpace);
 822     FlattenableUtils::read(buffer, size, crop);
 823     FlattenableUtils::read(buffer, size, scalingMode);
 824     FlattenableUtils::read(buffer, size, transform);
 825     FlattenableUtils::read(buffer, size, stickyTransform);
 826
 827     fence = new Fence();
 828     status_t result = fence->unflatten(buffer, size, fds, count);
 829     if (result != NO_ERROR) {
 830         return result;
 831     }
 832     return surfaceDamage.unflatten(buffer, size);
 833 }
 834
 835 }; // namespace android