libs/gui/IGraphicBufferConsumer.cpp

   1 /*
   2  * Copyright (C) 2013 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
  23 #include <binder/Parcel.h>
  24 #include <binder/IInterface.h>
  25
  26 #include <gui/IConsumerListener.h>
  27 #include <gui/IGraphicBufferConsumer.h>
  28
  29 #include <ui/GraphicBuffer.h>
  30 #include <ui/Fence.h>
  31
  32 #include <system/window.h>
  33
  34 namespace android {
  35 // ---------------------------------------------------------------------------
  36
  37 IGraphicBufferConsumer::BufferItem::BufferItem() :
  38     mTransform(0),
  39     mScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE),
  40     mTimestamp(0),
  41     mIsAutoTimestamp(false),
  42     mFrameNumber(0),
  43     mBuf(INVALID_BUFFER_SLOT),
  44     mIsDroppable(false),
  45     mAcquireCalled(false),
  46     mTransformToDisplayInverse(false) {
  47     mCrop.makeInvalid();
  48 }
  49
  50 size_t IGraphicBufferConsumer::BufferItem::getPodSize() const {
  51     size_t c =  sizeof(mCrop) +
  52             sizeof(mTransform) +
  53             sizeof(mScalingMode) +
  54             sizeof(mTimestamp) +
  55             sizeof(mIsAutoTimestamp) +
  56             sizeof(mFrameNumber) +
  57             sizeof(mBuf) +
  58             sizeof(mIsDroppable) +
  59             sizeof(mAcquireCalled) +
  60             sizeof(mTransformToDisplayInverse);
  61     return c;
  62 }
  63
  64 size_t IGraphicBufferConsumer::BufferItem::getFlattenedSize() const {
  65     size_t c = 0;
  66     if (mGraphicBuffer != 0) {
  67         c += mGraphicBuffer->getFlattenedSize();
  68         c = FlattenableUtils::align<4>(c);
  69     }
  70     if (mFence != 0) {
  71         c += mFence->getFlattenedSize();
  72         c = FlattenableUtils::align<4>(c);
  73     }
  74     return sizeof(int32_t) + c + getPodSize();
  75 }
  76
  77 size_t IGraphicBufferConsumer::BufferItem::getFdCount() const {
  78     size_t c = 0;
  79     if (mGraphicBuffer != 0) {
  80         c += mGraphicBuffer->getFdCount();
  81     }
  82     if (mFence != 0) {
  83         c += mFence->getFdCount();
  84     }
  85     return c;
  86 }
  87
  88 static void writeBoolAsInt(void*& buffer, size_t& size, bool b) {
  89     FlattenableUtils::write(buffer, size, static_cast<int32_t>(b));
  90 }
  91
  92 static bool readBoolFromInt(void const*& buffer, size_t& size) {
  93     int32_t i;
  94     FlattenableUtils::read(buffer, size, i);
  95     return static_cast<bool>(i);
  96 }
  97
  98 status_t IGraphicBufferConsumer::BufferItem::flatten(
  99         void*& buffer, size_t& size, int*& fds, size_t& count) const {
 100
 101     // make sure we have enough space
 102     if (size < BufferItem::getFlattenedSize()) {
 103         return NO_MEMORY;
 104     }
 105
 106     // content flags are stored first
 107     uint32_t& flags = *static_cast<uint32_t*>(buffer);
 108
 109     // advance the pointer
 110     FlattenableUtils::advance(buffer, size, sizeof(uint32_t));
 111
 112     flags = 0;
 113     if (mGraphicBuffer != 0) {
 114         status_t err = mGraphicBuffer->flatten(buffer, size, fds, count);
 115         if (err) return err;
 116         size -= FlattenableUtils::align<4>(buffer);
 117         flags |= 1;
 118     }
 119     if (mFence != 0) {
 120         status_t err = mFence->flatten(buffer, size, fds, count);
 121         if (err) return err;
 122         size -= FlattenableUtils::align<4>(buffer);
 123         flags |= 2;
 124     }
 125
 126     // check we have enough space (in case flattening the fence/graphicbuffer lied to us)
 127     if (size < getPodSize()) {
 128         return NO_MEMORY;
 129     }
 130
 131     FlattenableUtils::write(buffer, size, mCrop);
 132     FlattenableUtils::write(buffer, size, mTransform);
 133     FlattenableUtils::write(buffer, size, mScalingMode);
 134     FlattenableUtils::write(buffer, size, mTimestamp);
 135     writeBoolAsInt(buffer, size, mIsAutoTimestamp);
 136     FlattenableUtils::write(buffer, size, mFrameNumber);
 137     FlattenableUtils::write(buffer, size, mBuf);
 138     writeBoolAsInt(buffer, size, mIsDroppable);
 139     writeBoolAsInt(buffer, size, mAcquireCalled);
 140     writeBoolAsInt(buffer, size, mTransformToDisplayInverse);
 141
 142     return NO_ERROR;
 143 }
 144
 145 status_t IGraphicBufferConsumer::BufferItem::unflatten(
 146         void const*& buffer, size_t& size, int const*& fds, size_t& count) {
 147
 148     if (size < sizeof(uint32_t))
 149         return NO_MEMORY;
 150
 151     uint32_t flags = 0;
 152     FlattenableUtils::read(buffer, size, flags);
 153
 154     if (flags & 1) {
 155         mGraphicBuffer = new GraphicBuffer();
 156         status_t err = mGraphicBuffer->unflatten(buffer, size, fds, count);
 157         if (err) return err;
 158         size -= FlattenableUtils::align<4>(buffer);
 159     }
 160
 161     if (flags & 2) {
 162         mFence = new Fence();
 163         status_t err = mFence->unflatten(buffer, size, fds, count);
 164         if (err) return err;
 165         size -= FlattenableUtils::align<4>(buffer);
 166     }
 167
 168     // check we have enough space
 169     if (size < getPodSize()) {
 170         return NO_MEMORY;
 171     }
 172
 173     FlattenableUtils::read(buffer, size, mCrop);
 174     FlattenableUtils::read(buffer, size, mTransform);
 175     FlattenableUtils::read(buffer, size, mScalingMode);
 176     FlattenableUtils::read(buffer, size, mTimestamp);
 177     mIsAutoTimestamp = readBoolFromInt(buffer, size);
 178     FlattenableUtils::read(buffer, size, mFrameNumber);
 179     FlattenableUtils::read(buffer, size, mBuf);
 180     mIsDroppable = readBoolFromInt(buffer, size);
 181     mAcquireCalled = readBoolFromInt(buffer, size);
 182     mTransformToDisplayInverse = readBoolFromInt(buffer, size);
 183
 184     return NO_ERROR;
 185 }
 186
 187 // ---------------------------------------------------------------------------
 188
 189 enum {
 190     ACQUIRE_BUFFER = IBinder::FIRST_CALL_TRANSACTION,
 191     DETACH_BUFFER,
 192     ATTACH_BUFFER,
 193     RELEASE_BUFFER,
 194     CONSUMER_CONNECT,
 195     CONSUMER_DISCONNECT,
 196     GET_RELEASED_BUFFERS,
 197     SET_DEFAULT_BUFFER_SIZE,
 198     SET_DEFAULT_MAX_BUFFER_COUNT,
 199     DISABLE_ASYNC_BUFFER,
 200     SET_MAX_ACQUIRED_BUFFER_COUNT,
 201     SET_CONSUMER_NAME,
 202     SET_DEFAULT_BUFFER_FORMAT,
 203     SET_CONSUMER_USAGE_BITS,
 204     SET_TRANSFORM_HINT,
 205     GET_SIDEBAND_STREAM,
 206     DUMP,
 207 };
 208
 209
 210 class BpGraphicBufferConsumer : public BpInterface<IGraphicBufferConsumer>
 211 {
 212 public:
 213     BpGraphicBufferConsumer(const sp<IBinder>& impl)
 214         : BpInterface<IGraphicBufferConsumer>(impl)
 215     {
 216     }
 217
 218     virtual status_t acquireBuffer(BufferItem *buffer, nsecs_t presentWhen) {
 219         Parcel data, reply;
 220         data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
 221         data.writeInt64(presentWhen);
 222         status_t result = remote()->transact(ACQUIRE_BUFFER, data, &reply);
 223         if (result != NO_ERROR) {
 224             return result;
 225         }
 226         result = reply.read(*buffer);
 227         if (result != NO_ERROR) {
 228             return result;
 229         }
 230         return reply.readInt32();
 231     }
 232
 233     virtual status_t detachBuffer(int slot) {
 234         Parcel data, reply;
 235         data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
 236         data.writeInt32(slot);
 237         status_t result = remote()->transact(DETACH_BUFFER, data, &reply);
 238         if (result != NO_ERROR) {
 239             return result;
 240         }
 241         result = reply.readInt32();
 242         return result;
 243     }
 244
 245     virtual status_t attachBuffer(int* slot, const sp<GraphicBuffer>& buffer) {
 246         Parcel data, reply;
 247         data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
 248         data.write(*buffer.get());
 249         status_t result = remote()->transact(ATTACH_BUFFER, data, &reply);
 250         if (result != NO_ERROR) {
 251             return result;
 252         }
 253         *slot = reply.readInt32();
 254         result = reply.readInt32();
 255         return result;
 256     }
 257
 258     virtual status_t releaseBuffer(int buf, uint64_t frameNumber,
 259             EGLDisplay display __attribute__((unused)), EGLSyncKHR fence __attribute__((unused)),
 260             const sp<Fence>& releaseFence) {
 261         Parcel data, reply;
 262         data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
 263         data.writeInt32(buf);
 264         data.writeInt64(frameNumber);
 265         data.write(*releaseFence);
 266         status_t result = remote()->transact(RELEASE_BUFFER, data, &reply);
 267         if (result != NO_ERROR) {
 268             return result;
 269         }
 270         return reply.readInt32();
 271     }
 272
 273     virtual status_t consumerConnect(const sp<IConsumerListener>& consumer, bool controlledByApp) {
 274         Parcel data, reply;
 275         data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
 276         data.writeStrongBinder(consumer->asBinder());
 277         data.writeInt32(controlledByApp);
 278         status_t result = remote()->transact(CONSUMER_CONNECT, data, &reply);
 279         if (result != NO_ERROR) {
 280             return result;
 281         }
 282         return reply.readInt32();
 283     }
 284
 285     virtual status_t consumerDisconnect() {
 286         Parcel data, reply;
 287         data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
 288         status_t result = remote()->transact(CONSUMER_DISCONNECT, data, &reply);
 289         if (result != NO_ERROR) {
 290             return result;
 291         }
 292         return reply.readInt32();
 293     }
 294
 295     virtual status_t getReleasedBuffers(uint64_t* slotMask) {
 296         Parcel data, reply;
 297         if (slotMask == NULL) {
 298             ALOGE("getReleasedBuffers: slotMask must not be NULL");
 299             return BAD_VALUE;
 300         }
 301         data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
 302         status_t result = remote()->transact(GET_RELEASED_BUFFERS, data, &reply);
 303         if (result != NO_ERROR) {
 304             return result;
 305         }
 306         *slotMask = reply.readInt64();
 307         return reply.readInt32();
 308     }
 309
 310     virtual status_t setDefaultBufferSize(uint32_t w, uint32_t h) {
 311         Parcel data, reply;
 312         data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
 313         data.writeInt32(w);
 314         data.writeInt32(h);
 315         status_t result = remote()->transact(SET_DEFAULT_BUFFER_SIZE, data, &reply);
 316         if (result != NO_ERROR) {
 317             return result;
 318         }
 319         return reply.readInt32();
 320     }
 321
 322     virtual status_t setDefaultMaxBufferCount(int bufferCount) {
 323         Parcel data, reply;
 324         data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
 325         data.writeInt32(bufferCount);
 326         status_t result = remote()->transact(SET_DEFAULT_MAX_BUFFER_COUNT, data, &reply);
 327         if (result != NO_ERROR) {
 328             return result;
 329         }
 330         return reply.readInt32();
 331     }
 332
 333     virtual status_t disableAsyncBuffer() {
 334         Parcel data, reply;
 335         data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
 336         status_t result = remote()->transact(DISABLE_ASYNC_BUFFER, data, &reply);
 337         if (result != NO_ERROR) {
 338             return result;
 339         }
 340         return reply.readInt32();
 341     }
 342
 343     virtual status_t setMaxAcquiredBufferCount(int maxAcquiredBuffers) {
 344         Parcel data, reply;
 345         data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
 346         data.writeInt32(maxAcquiredBuffers);
 347         status_t result = remote()->transact(SET_MAX_ACQUIRED_BUFFER_COUNT, data, &reply);
 348         if (result != NO_ERROR) {
 349             return result;
 350         }
 351         return reply.readInt32();
 352     }
 353
 354     virtual void setConsumerName(const String8& name) {
 355         Parcel data, reply;
 356         data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
 357         data.writeString8(name);
 358         remote()->transact(SET_CONSUMER_NAME, data, &reply);
 359     }
 360
 361     virtual status_t setDefaultBufferFormat(uint32_t defaultFormat) {
 362         Parcel data, reply;
 363         data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
 364         data.writeInt32(defaultFormat);
 365         status_t result = remote()->transact(SET_DEFAULT_BUFFER_FORMAT, data, &reply);
 366         if (result != NO_ERROR) {
 367             return result;
 368         }
 369         return reply.readInt32();
 370     }
 371
 372     virtual status_t setConsumerUsageBits(uint32_t usage) {
 373         Parcel data, reply;
 374         data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
 375         data.writeInt32(usage);
 376         status_t result = remote()->transact(SET_CONSUMER_USAGE_BITS, data, &reply);
 377         if (result != NO_ERROR) {
 378             return result;
 379         }
 380         return reply.readInt32();
 381     }
 382
 383     virtual status_t setTransformHint(uint32_t hint) {
 384         Parcel data, reply;
 385         data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
 386         data.writeInt32(hint);
 387         status_t result = remote()->transact(SET_TRANSFORM_HINT, data, &reply);
 388         if (result != NO_ERROR) {
 389             return result;
 390         }
 391         return reply.readInt32();
 392     }
 393
 394     virtual sp<NativeHandle> getSidebandStream() const {
 395         Parcel data, reply;
 396         status_t err;
 397         data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
 398         if ((err = remote()->transact(GET_SIDEBAND_STREAM, data, &reply)) != NO_ERROR) {
 399             return NULL;
 400         }
 401         sp<NativeHandle> stream;
 402         if (reply.readInt32()) {
 403             stream = NativeHandle::create(reply.readNativeHandle(), true);
 404         }
 405         return stream;
 406     }
 407
 408     virtual void dump(String8& result, const char* prefix) const {
 409         Parcel data, reply;
 410         data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
 411         data.writeString8(result);
 412         data.writeString8(String8(prefix ? prefix : ""));
 413         remote()->transact(DUMP, data, &reply);
 414         reply.readString8();
 415     }
 416 };
 417
 418 IMPLEMENT_META_INTERFACE(GraphicBufferConsumer, "android.gui.IGraphicBufferConsumer");
 419
 420 // ----------------------------------------------------------------------
 421
 422 status_t BnGraphicBufferConsumer::onTransact(
 423         uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
 424 {
 425     switch(code) {
 426         case ACQUIRE_BUFFER: {
 427             CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
 428             BufferItem item;
 429             int64_t presentWhen = data.readInt64();
 430             status_t result = acquireBuffer(&item, presentWhen);
 431             status_t err = reply->write(item);
 432             if (err) return err;
 433             reply->writeInt32(result);
 434             return NO_ERROR;
 435         } break;
 436         case DETACH_BUFFER: {
 437             CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
 438             int slot = data.readInt32();
 439             int result = detachBuffer(slot);
 440             reply->writeInt32(result);
 441             return NO_ERROR;
 442         } break;
 443         case ATTACH_BUFFER: {
 444             CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
 445             sp<GraphicBuffer> buffer = new GraphicBuffer();
 446             data.read(*buffer.get());
 447             int slot;
 448             int result = attachBuffer(&slot, buffer);
 449             reply->writeInt32(slot);
 450             reply->writeInt32(result);
 451             return NO_ERROR;
 452         } break;
 453         case RELEASE_BUFFER: {
 454             CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
 455             int buf = data.readInt32();
 456             uint64_t frameNumber = data.readInt64();
 457             sp<Fence> releaseFence = new Fence();
 458             status_t err = data.read(*releaseFence);
 459             if (err) return err;
 460             status_t result = releaseBuffer(buf, frameNumber,
 461                     EGL_NO_DISPLAY, EGL_NO_SYNC_KHR, releaseFence);
 462             reply->writeInt32(result);
 463             return NO_ERROR;
 464         } break;
 465         case CONSUMER_CONNECT: {
 466             CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
 467             sp<IConsumerListener> consumer = IConsumerListener::asInterface( data.readStrongBinder() );
 468             bool controlledByApp = data.readInt32();
 469             status_t result = consumerConnect(consumer, controlledByApp);
 470             reply->writeInt32(result);
 471             return NO_ERROR;
 472         } break;
 473         case CONSUMER_DISCONNECT: {
 474             CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
 475             status_t result = consumerDisconnect();
 476             reply->writeInt32(result);
 477             return NO_ERROR;
 478         } break;
 479         case GET_RELEASED_BUFFERS: {
 480             CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
 481             uint64_t slotMask;
 482             status_t result = getReleasedBuffers(&slotMask);
 483             reply->writeInt64(slotMask);
 484             reply->writeInt32(result);
 485             return NO_ERROR;
 486         } break;
 487         case SET_DEFAULT_BUFFER_SIZE: {
 488             CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
 489             uint32_t w = data.readInt32();
 490             uint32_t h = data.readInt32();
 491             status_t result = setDefaultBufferSize(w, h);
 492             reply->writeInt32(result);
 493             return NO_ERROR;
 494         } break;
 495         case SET_DEFAULT_MAX_BUFFER_COUNT: {
 496             CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
 497             uint32_t bufferCount = data.readInt32();
 498             status_t result = setDefaultMaxBufferCount(bufferCount);
 499             reply->writeInt32(result);
 500             return NO_ERROR;
 501         } break;
 502         case DISABLE_ASYNC_BUFFER: {
 503             CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
 504             status_t result = disableAsyncBuffer();
 505             reply->writeInt32(result);
 506             return NO_ERROR;
 507         } break;
 508         case SET_MAX_ACQUIRED_BUFFER_COUNT: {
 509             CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
 510             uint32_t maxAcquiredBuffers = data.readInt32();
 511             status_t result = setMaxAcquiredBufferCount(maxAcquiredBuffers);
 512             reply->writeInt32(result);
 513             return NO_ERROR;
 514         } break;
 515         case SET_CONSUMER_NAME: {
 516             CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
 517             setConsumerName( data.readString8() );
 518             return NO_ERROR;
 519         } break;
 520         case SET_DEFAULT_BUFFER_FORMAT: {
 521             CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
 522             uint32_t defaultFormat = data.readInt32();
 523             status_t result = setDefaultBufferFormat(defaultFormat);
 524             reply->writeInt32(result);
 525             return NO_ERROR;
 526         } break;
 527         case SET_CONSUMER_USAGE_BITS: {
 528             CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
 529             uint32_t usage = data.readInt32();
 530             status_t result = setConsumerUsageBits(usage);
 531             reply->writeInt32(result);
 532             return NO_ERROR;
 533         } break;
 534         case SET_TRANSFORM_HINT: {
 535             CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
 536             uint32_t hint = data.readInt32();
 537             status_t result = setTransformHint(hint);
 538             reply->writeInt32(result);
 539             return NO_ERROR;
 540         } break;
 541         case DUMP: {
 542             CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
 543             String8 result = data.readString8();
 544             String8 prefix = data.readString8();
 545             static_cast<IGraphicBufferConsumer*>(this)->dump(result, prefix);
 546             reply->writeString8(result);
 547             return NO_ERROR;
 548         }
 549     }
 550     return BBinder::onTransact(code, data, reply, flags);
 551 }
 552
 553 }; // namespace android