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) {
 274         Parcel data, reply;
 275         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 276         data.writeInt32(api);
 277         status_t result =remote()->transact(DISCONNECT, data, &reply);
 278         if (result != NO_ERROR) {
 279             return result;
 280         }
 281         result = reply.readInt32();
 282         return result;
 283     }
 284
 285     virtual status_t setSidebandStream(const sp<NativeHandle>& stream) {
 286         Parcel data, reply;
 287         status_t result;
 288         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 289         if (stream.get()) {
 290             data.writeInt32(true);
 291             data.writeNativeHandle(stream->handle());
 292         } else {
 293             data.writeInt32(false);
 294         }
 295         if ((result = remote()->transact(SET_SIDEBAND_STREAM, data, &reply)) == NO_ERROR) {
 296             result = reply.readInt32();
 297         }
 298         return result;
 299     }
 300
 301     virtual void allocateBuffers(uint32_t width, uint32_t height,
 302             PixelFormat format, uint32_t usage) {
 303         Parcel data, reply;
 304         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 305         data.writeUint32(width);
 306         data.writeUint32(height);
 307         data.writeInt32(static_cast<int32_t>(format));
 308         data.writeUint32(usage);
 309         status_t result = remote()->transact(ALLOCATE_BUFFERS, data, &reply);
 310         if (result != NO_ERROR) {
 311             ALOGE("allocateBuffers failed to transact: %d", result);
 312         }
 313     }
 314
 315     virtual status_t allowAllocation(bool allow) {
 316         Parcel data, reply;
 317         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 318         data.writeInt32(static_cast<int32_t>(allow));
 319         status_t result = remote()->transact(ALLOW_ALLOCATION, data, &reply);
 320         if (result != NO_ERROR) {
 321             return result;
 322         }
 323         result = reply.readInt32();
 324         return result;
 325     }
 326
 327     virtual status_t setGenerationNumber(uint32_t generationNumber) {
 328         Parcel data, reply;
 329         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 330         data.writeUint32(generationNumber);
 331         status_t result = remote()->transact(SET_GENERATION_NUMBER, data, &reply);
 332         if (result == NO_ERROR) {
 333             result = reply.readInt32();
 334         }
 335         return result;
 336     }
 337
 338     virtual String8 getConsumerName() const {
 339         Parcel data, reply;
 340         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 341         status_t result = remote()->transact(GET_CONSUMER_NAME, data, &reply);
 342         if (result != NO_ERROR) {
 343             ALOGE("getConsumerName failed to transact: %d", result);
 344             return String8("TransactFailed");
 345         }
 346         return reply.readString8();
 347     }
 348
 349     virtual status_t setSharedBufferMode(bool sharedBufferMode) {
 350         Parcel data, reply;
 351         data.writeInterfaceToken(
 352                 IGraphicBufferProducer::getInterfaceDescriptor());
 353         data.writeInt32(sharedBufferMode);
 354         status_t result = remote()->transact(SET_SHARED_BUFFER_MODE, data,
 355                 &reply);
 356         if (result == NO_ERROR) {
 357             result = reply.readInt32();
 358         }
 359         return result;
 360     }
 361
 362     virtual status_t setAutoRefresh(bool autoRefresh) {
 363         Parcel data, reply;
 364         data.writeInterfaceToken(
 365                 IGraphicBufferProducer::getInterfaceDescriptor());
 366         data.writeInt32(autoRefresh);
 367         status_t result = remote()->transact(SET_AUTO_REFRESH, data, &reply);
 368         if (result == NO_ERROR) {
 369             result = reply.readInt32();
 370         }
 371         return result;
 372     }
 373
 374     virtual status_t setDequeueTimeout(nsecs_t timeout) {
 375         Parcel data, reply;
 376         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 377         data.writeInt64(timeout);
 378         status_t result = remote()->transact(SET_DEQUEUE_TIMEOUT, data, &reply);
 379         if (result != NO_ERROR) {
 380             ALOGE("setDequeueTimeout failed to transact: %d", result);
 381             return result;
 382         }
 383         return reply.readInt32();
 384     }
 385
 386     virtual status_t getLastQueuedBuffer(sp<GraphicBuffer>* outBuffer,
 387             sp<Fence>* outFence, float outTransformMatrix[16]) override {
 388         Parcel data, reply;
 389         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 390         status_t result = remote()->transact(GET_LAST_QUEUED_BUFFER, data,
 391                 &reply);
 392         if (result != NO_ERROR) {
 393             ALOGE("getLastQueuedBuffer failed to transact: %d", result);
 394             return result;
 395         }
 396         result = reply.readInt32();
 397         if (result != NO_ERROR) {
 398             return result;
 399         }
 400         bool hasBuffer = reply.readBool();
 401         sp<GraphicBuffer> buffer;
 402         if (hasBuffer) {
 403             buffer = new GraphicBuffer();
 404             result = reply.read(*buffer);
 405             if (result == NO_ERROR) {
 406                 result = reply.read(outTransformMatrix, sizeof(float) * 16);
 407             }
 408         }
 409         if (result != NO_ERROR) {
 410             ALOGE("getLastQueuedBuffer failed to read buffer: %d", result);
 411             return result;
 412         }
 413         sp<Fence> fence(new Fence);
 414         result = reply.read(*fence);
 415         if (result != NO_ERROR) {
 416             ALOGE("getLastQueuedBuffer failed to read fence: %d", result);
 417             return result;
 418         }
 419         *outBuffer = buffer;
 420         *outFence = fence;
 421         return result;
 422     }
 423
 424     virtual bool getFrameTimestamps(uint64_t frameNumber,
 425                 FrameTimestamps* outTimestamps) const {
 426         Parcel data, reply;
 427         status_t result = data.writeInterfaceToken(
 428                 IGraphicBufferProducer::getInterfaceDescriptor());
 429         if (result != NO_ERROR) {
 430             ALOGE("getFrameTimestamps failed to write token: %d", result);
 431             return false;
 432         }
 433         result = data.writeUint64(frameNumber);
 434         if (result != NO_ERROR) {
 435             ALOGE("getFrameTimestamps failed to write: %d", result);
 436             return false;
 437         }
 438         result = remote()->transact(GET_FRAME_TIMESTAMPS, data, &reply);
 439         if (result != NO_ERROR) {
 440             ALOGE("getFrameTimestamps failed to transact: %d", result);
 441             return false;
 442         }
 443         bool found = false;
 444         result = reply.readBool(&found);
 445         if (result != NO_ERROR) {
 446             ALOGE("getFrameTimestamps failed to read: %d", result);
 447             return false;
 448         }
 449         if (found) {
 450             result = reply.read(*outTimestamps);
 451             if (result != NO_ERROR) {
 452                 ALOGE("getFrameTimestamps failed to read timestamps: %d",
 453                         result);
 454                 return false;
 455             }
 456         }
 457         return found;
 458     }
 459
 460     virtual status_t getUniqueId(uint64_t* outId) const {
 461         Parcel data, reply;
 462         data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
 463         status_t result = remote()->transact(GET_UNIQUE_ID, data, &reply);
 464         if (result != NO_ERROR) {
 465             ALOGE("getUniqueId failed to transact: %d", result);
 466         }
 467         status_t actualResult = NO_ERROR;
 468         result = reply.readInt32(&actualResult);
 469         if (result != NO_ERROR) {
 470             return result;
 471         }
 472         result = reply.readUint64(outId);
 473         if (result != NO_ERROR) {
 474             return result;
 475         }
 476         return actualResult;
 477     }
 478 };
 479
 480 // Out-of-line virtual method definition to trigger vtable emission in this
 481 // translation unit (see clang warning -Wweak-vtables)
 482 BpGraphicBufferProducer::~BpGraphicBufferProducer() {}
 483
 484 IMPLEMENT_META_INTERFACE(GraphicBufferProducer, "android.gui.IGraphicBufferProducer");
 485
 486 // ----------------------------------------------------------------------
 487
 488 status_t BnGraphicBufferProducer::onTransact(
 489     uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
 490 {
 491     switch(code) {
 492         case REQUEST_BUFFER: {
 493             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 494             int bufferIdx   = data.readInt32();
 495             sp<GraphicBuffer> buffer;
 496             int result = requestBuffer(bufferIdx, &buffer);
 497             reply->writeInt32(buffer != 0);
 498             if (buffer != 0) {
 499                 reply->write(*buffer);
 500             }
 501             reply->writeInt32(result);
 502             return NO_ERROR;
 503         }
 504         case SET_MAX_DEQUEUED_BUFFER_COUNT: {
 505             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 506             int maxDequeuedBuffers = data.readInt32();
 507             int result = setMaxDequeuedBufferCount(maxDequeuedBuffers);
 508             reply->writeInt32(result);
 509             return NO_ERROR;
 510         }
 511         case SET_ASYNC_MODE: {
 512             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 513             bool async = data.readInt32();
 514             int result = setAsyncMode(async);
 515             reply->writeInt32(result);
 516             return NO_ERROR;
 517         }
 518         case DEQUEUE_BUFFER: {
 519             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 520             uint32_t width = data.readUint32();
 521             uint32_t height = data.readUint32();
 522             PixelFormat format = static_cast<PixelFormat>(data.readInt32());
 523             uint32_t usage = data.readUint32();
 524             int buf = 0;
 525             sp<Fence> fence;
 526             int result = dequeueBuffer(&buf, &fence, width, height, format,
 527                     usage);
 528             reply->writeInt32(buf);
 529             reply->writeInt32(fence != NULL);
 530             if (fence != NULL) {
 531                 reply->write(*fence);
 532             }
 533             reply->writeInt32(result);
 534             return NO_ERROR;
 535         }
 536         case DETACH_BUFFER: {
 537             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 538             int slot = data.readInt32();
 539             int result = detachBuffer(slot);
 540             reply->writeInt32(result);
 541             return NO_ERROR;
 542         }
 543         case DETACH_NEXT_BUFFER: {
 544             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 545             sp<GraphicBuffer> buffer;
 546             sp<Fence> fence;
 547             int32_t result = detachNextBuffer(&buffer, &fence);
 548             reply->writeInt32(result);
 549             if (result == NO_ERROR) {
 550                 reply->writeInt32(buffer != NULL);
 551                 if (buffer != NULL) {
 552                     reply->write(*buffer);
 553                 }
 554                 reply->writeInt32(fence != NULL);
 555                 if (fence != NULL) {
 556                     reply->write(*fence);
 557                 }
 558             }
 559             return NO_ERROR;
 560         }
 561         case ATTACH_BUFFER: {
 562             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 563             sp<GraphicBuffer> buffer = new GraphicBuffer();
 564             status_t result = data.read(*buffer.get());
 565             int slot = 0;
 566             if (result == NO_ERROR) {
 567                 result = attachBuffer(&slot, buffer);
 568             }
 569             reply->writeInt32(slot);
 570             reply->writeInt32(result);
 571             return NO_ERROR;
 572         }
 573         case QUEUE_BUFFER: {
 574             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 575             int buf = data.readInt32();
 576             QueueBufferInput input(data);
 577             QueueBufferOutput* const output =
 578                     reinterpret_cast<QueueBufferOutput *>(
 579                             reply->writeInplace(sizeof(QueueBufferOutput)));
 580             memset(output, 0, sizeof(QueueBufferOutput));
 581             status_t result = queueBuffer(buf, input, output);
 582             reply->writeInt32(result);
 583             return NO_ERROR;
 584         }
 585         case CANCEL_BUFFER: {
 586             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 587             int buf = data.readInt32();
 588             sp<Fence> fence = new Fence();
 589             status_t result = data.read(*fence.get());
 590             if (result == NO_ERROR) {
 591                 result = cancelBuffer(buf, fence);
 592             }
 593             reply->writeInt32(result);
 594             return NO_ERROR;
 595         }
 596         case QUERY: {
 597             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 598             int value = 0;
 599             int what = data.readInt32();
 600             int res = query(what, &value);
 601             reply->writeInt32(value);
 602             reply->writeInt32(res);
 603             return NO_ERROR;
 604         }
 605         case CONNECT: {
 606             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 607             sp<IProducerListener> listener;
 608             if (data.readInt32() == 1) {
 609                 listener = IProducerListener::asInterface(data.readStrongBinder());
 610             }
 611             int api = data.readInt32();
 612             bool producerControlledByApp = data.readInt32();
 613             QueueBufferOutput* const output =
 614                     reinterpret_cast<QueueBufferOutput *>(
 615                             reply->writeInplace(sizeof(QueueBufferOutput)));
 616             memset(output, 0, sizeof(QueueBufferOutput));
 617             status_t res = connect(listener, api, producerControlledByApp, output);
 618             reply->writeInt32(res);
 619             return NO_ERROR;
 620         }
 621         case DISCONNECT: {
 622             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 623             int api = data.readInt32();
 624             status_t res = disconnect(api);
 625             reply->writeInt32(res);
 626             return NO_ERROR;
 627         }
 628         case SET_SIDEBAND_STREAM: {
 629             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 630             sp<NativeHandle> stream;
 631             if (data.readInt32()) {
 632                 stream = NativeHandle::create(data.readNativeHandle(), true);
 633             }
 634             status_t result = setSidebandStream(stream);
 635             reply->writeInt32(result);
 636             return NO_ERROR;
 637         }
 638         case ALLOCATE_BUFFERS: {
 639             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 640             uint32_t width = data.readUint32();
 641             uint32_t height = data.readUint32();
 642             PixelFormat format = static_cast<PixelFormat>(data.readInt32());
 643             uint32_t usage = data.readUint32();
 644             allocateBuffers(width, height, format, usage);
 645             return NO_ERROR;
 646         }
 647         case ALLOW_ALLOCATION: {
 648             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 649             bool allow = static_cast<bool>(data.readInt32());
 650             status_t result = allowAllocation(allow);
 651             reply->writeInt32(result);
 652             return NO_ERROR;
 653         }
 654         case SET_GENERATION_NUMBER: {
 655             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 656             uint32_t generationNumber = data.readUint32();
 657             status_t result = setGenerationNumber(generationNumber);
 658             reply->writeInt32(result);
 659             return NO_ERROR;
 660         }
 661         case GET_CONSUMER_NAME: {
 662             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 663             reply->writeString8(getConsumerName());
 664             return NO_ERROR;
 665         }
 666         case SET_SHARED_BUFFER_MODE: {
 667             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 668             bool sharedBufferMode = data.readInt32();
 669             status_t result = setSharedBufferMode(sharedBufferMode);
 670             reply->writeInt32(result);
 671             return NO_ERROR;
 672         }
 673         case SET_AUTO_REFRESH: {
 674             CHECK_INTERFACE(IGraphicBuffer, data, reply);
 675             bool autoRefresh = data.readInt32();
 676             status_t result = setAutoRefresh(autoRefresh);
 677             reply->writeInt32(result);
 678             return NO_ERROR;
 679         }
 680         case SET_DEQUEUE_TIMEOUT: {
 681             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 682             nsecs_t timeout = data.readInt64();
 683             status_t result = setDequeueTimeout(timeout);
 684             reply->writeInt32(result);
 685             return NO_ERROR;
 686         }
 687         case GET_LAST_QUEUED_BUFFER: {
 688             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 689             sp<GraphicBuffer> buffer(nullptr);
 690             sp<Fence> fence(Fence::NO_FENCE);
 691             float transform[16] = {};
 692             status_t result = getLastQueuedBuffer(&buffer, &fence, transform);
 693             reply->writeInt32(result);
 694             if (result != NO_ERROR) {
 695                 return result;
 696             }
 697             if (!buffer.get()) {
 698                 reply->writeBool(false);
 699             } else {
 700                 reply->writeBool(true);
 701                 result = reply->write(*buffer);
 702                 if (result == NO_ERROR) {
 703                     reply->write(transform, sizeof(float) * 16);
 704                 }
 705             }
 706             if (result != NO_ERROR) {
 707                 ALOGE("getLastQueuedBuffer failed to write buffer: %d", result);
 708                 return result;
 709             }
 710             result = reply->write(*fence);
 711             if (result != NO_ERROR) {
 712                 ALOGE("getLastQueuedBuffer failed to write fence: %d", result);
 713                 return result;
 714             }
 715             return NO_ERROR;
 716         }
 717         case GET_FRAME_TIMESTAMPS: {
 718             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 719             uint64_t frameNumber = 0;
 720             status_t result = data.readUint64(&frameNumber);
 721             if (result != NO_ERROR) {
 722                 ALOGE("onTransact failed to read: %d", result);
 723                 return result;
 724             }
 725             FrameTimestamps timestamps;
 726             bool found = getFrameTimestamps(frameNumber, &timestamps);
 727             result = reply->writeBool(found);
 728             if (result != NO_ERROR) {
 729                 ALOGE("onTransact failed to write: %d", result);
 730                 return result;
 731             }
 732             if (found) {
 733                 result = reply->write(timestamps);
 734                 if (result != NO_ERROR) {
 735                     ALOGE("onTransact failed to write timestamps: %d", result);
 736                     return result;
 737                 }
 738             }
 739             return NO_ERROR;
 740         }
 741         case GET_UNIQUE_ID: {
 742             CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
 743             uint64_t outId = 0;
 744             status_t actualResult = getUniqueId(&outId);
 745             status_t result = reply->writeInt32(actualResult);
 746             if (result != NO_ERROR) {
 747                 return result;
 748             }
 749             result = reply->writeUint64(outId);
 750             if (result != NO_ERROR) {
 751                 return result;
 752             }
 753             return NO_ERROR;
 754         }
 755     }
 756     return BBinder::onTransact(code, data, reply, flags);
 757 }
 758
 759 // ----------------------------------------------------------------------------
 760
 761 IGraphicBufferProducer::QueueBufferInput::QueueBufferInput(const Parcel& parcel) {
 762     parcel.read(*this);
 763 }
 764
 765 size_t IGraphicBufferProducer::QueueBufferInput::getFlattenedSize() const {
 766     return sizeof(timestamp)
 767          + sizeof(isAutoTimestamp)
 768          + sizeof(dataSpace)
 769          + sizeof(crop)
 770          + sizeof(scalingMode)
 771          + sizeof(transform)
 772          + sizeof(stickyTransform)
 773          + fence->getFlattenedSize()
 774          + surfaceDamage.getFlattenedSize();
 775 }
 776
 777 size_t IGraphicBufferProducer::QueueBufferInput::getFdCount() const {
 778     return fence->getFdCount();
 779 }
 780
 781 status_t IGraphicBufferProducer::QueueBufferInput::flatten(
 782         void*& buffer, size_t& size, int*& fds, size_t& count) const
 783 {
 784     if (size < getFlattenedSize()) {
 785         return NO_MEMORY;
 786     }
 787     FlattenableUtils::write(buffer, size, timestamp);
 788     FlattenableUtils::write(buffer, size, isAutoTimestamp);
 789     FlattenableUtils::write(buffer, size, dataSpace);
 790     FlattenableUtils::write(buffer, size, crop);
 791     FlattenableUtils::write(buffer, size, scalingMode);
 792     FlattenableUtils::write(buffer, size, transform);
 793     FlattenableUtils::write(buffer, size, stickyTransform);
 794     status_t result = fence->flatten(buffer, size, fds, count);
 795     if (result != NO_ERROR) {
 796         return result;
 797     }
 798     return surfaceDamage.flatten(buffer, size);
 799 }
 800
 801 status_t IGraphicBufferProducer::QueueBufferInput::unflatten(
 802         void const*& buffer, size_t& size, int const*& fds, size_t& count)
 803 {
 804     size_t minNeeded =
 805               sizeof(timestamp)
 806             + sizeof(isAutoTimestamp)
 807             + sizeof(dataSpace)
 808             + sizeof(crop)
 809             + sizeof(scalingMode)
 810             + sizeof(transform)
 811             + sizeof(stickyTransform);
 812
 813     if (size < minNeeded) {
 814         return NO_MEMORY;
 815     }
 816
 817     FlattenableUtils::read(buffer, size, timestamp);
 818     FlattenableUtils::read(buffer, size, isAutoTimestamp);
 819     FlattenableUtils::read(buffer, size, dataSpace);
 820     FlattenableUtils::read(buffer, size, crop);
 821     FlattenableUtils::read(buffer, size, scalingMode);
 822     FlattenableUtils::read(buffer, size, transform);
 823     FlattenableUtils::read(buffer, size, stickyTransform);
 824
 825     fence = new Fence();
 826     status_t result = fence->unflatten(buffer, size, fds, count);
 827     if (result != NO_ERROR) {
 828         return result;
 829     }
 830     return surfaceDamage.unflatten(buffer, size);
 831 }
 832
 833 }; // namespace android