The Tor Browser / file revision

widget/gonk/nativewindow/IGonkGraphicBufferConsumer.cpp@6474c204b198

widget/gonk/nativewindow/IGonkGraphicBufferConsumer.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author
Michael Schloh von Bennewitz <michael@schloh.com>
date
Wed, 31 Dec 2014 06:09:35 +0100
changeset 0
6474c204b198
permissions
-rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     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 #define EGL_EGLEXT_PROTOTYPES

    18 

    19 #include <stdint.h>

    20 #include <sys/types.h>

    21 

    22 #include <utils/Errors.h>

    23 

    24 #include <binder/Parcel.h>

    25 #include <binder/IInterface.h>

    26 

    27 #include <gui/IConsumerListener.h>

    28 #include "IGonkGraphicBufferConsumer.h"

    29 

    30 #include <ui/GraphicBuffer.h>

    31 #include <ui/Fence.h>

    32 

    33 #include <system/window.h>

    34 

    35 namespace android {

    36 // ---------------------------------------------------------------------------

    37 

    38 IGonkGraphicBufferConsumer::BufferItem::BufferItem() :

    39     mTransform(0),

    40     mScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE),

    41     mTimestamp(0),

    42     mIsAutoTimestamp(false),

    43     mFrameNumber(0),

    44     mBuf(INVALID_BUFFER_SLOT),

    45     mIsDroppable(false),

    46     mAcquireCalled(false),

    47     mTransformToDisplayInverse(false) {

    48     mCrop.makeInvalid();

    49 }

    50 

    51 size_t IGonkGraphicBufferConsumer::BufferItem::getPodSize() const {

    52     size_t c =  sizeof(mCrop) +

    53             sizeof(mTransform) +

    54             sizeof(mScalingMode) +

    55             sizeof(mTimestamp) +

    56             sizeof(mIsAutoTimestamp) +

    57             sizeof(mFrameNumber) +

    58             sizeof(mBuf) +

    59             sizeof(mIsDroppable) +

    60             sizeof(mAcquireCalled) +

    61             sizeof(mTransformToDisplayInverse);

    62     return c;

    63 }

    64 

    65 size_t IGonkGraphicBufferConsumer::BufferItem::getFlattenedSize() const {

    66     size_t c = 0;

    67     if (mGraphicBuffer != 0) {

    68         c += mGraphicBuffer->getFlattenedSize();

    69         FlattenableUtils::align<4>(c);

    70     }

    71     if (mFence != 0) {

    72         c += mFence->getFlattenedSize();

    73         FlattenableUtils::align<4>(c);

    74     }

    75     return sizeof(int32_t) + c + getPodSize();

    76 }

    77 

    78 size_t IGonkGraphicBufferConsumer::BufferItem::getFdCount() const {

    79     size_t c = 0;

    80     if (mGraphicBuffer != 0) {

    81         c += mGraphicBuffer->getFdCount();

    82     }

    83     if (mFence != 0) {

    84         c += mFence->getFdCount();

    85     }

    86     return c;

    87 }

    88 

    89 status_t IGonkGraphicBufferConsumer::BufferItem::flatten(

    90         void*& buffer, size_t& size, int*& fds, size_t& count) const {

    91 

    92     // make sure we have enough space

    93     if (count < BufferItem::getFlattenedSize()) {

    94         return NO_MEMORY;

    95     }

    96 

    97     // content flags are stored first

    98     uint32_t& flags = *static_cast<uint32_t*>(buffer);

    99 

   100     // advance the pointer

   101     FlattenableUtils::advance(buffer, size, sizeof(uint32_t));

   102 

   103     flags = 0;

   104     if (mGraphicBuffer != 0) {

   105         status_t err = mGraphicBuffer->flatten(buffer, size, fds, count);

   106         if (err) return err;

   107         size -= FlattenableUtils::align<4>(buffer);

   108         flags |= 1;

   109     }

   110     if (mFence != 0) {

   111         status_t err = mFence->flatten(buffer, size, fds, count);

   112         if (err) return err;

   113         size -= FlattenableUtils::align<4>(buffer);

   114         flags |= 2;

   115     }

   116 

   117     // check we have enough space (in case flattening the fence/graphicbuffer lied to us)

   118     if (size < getPodSize()) {

   119         return NO_MEMORY;

   120     }

   121 

   122     FlattenableUtils::write(buffer, size, mCrop);

   123     FlattenableUtils::write(buffer, size, mTransform);

   124     FlattenableUtils::write(buffer, size, mScalingMode);

   125     FlattenableUtils::write(buffer, size, mTimestamp);

   126     FlattenableUtils::write(buffer, size, mIsAutoTimestamp);

   127     FlattenableUtils::write(buffer, size, mFrameNumber);

   128     FlattenableUtils::write(buffer, size, mBuf);

   129     FlattenableUtils::write(buffer, size, mIsDroppable);

   130     FlattenableUtils::write(buffer, size, mAcquireCalled);

   131     FlattenableUtils::write(buffer, size, mTransformToDisplayInverse);

   132 

   133     return NO_ERROR;

   134 }

   135 

   136 status_t IGonkGraphicBufferConsumer::BufferItem::unflatten(

   137         void const*& buffer, size_t& size, int const*& fds, size_t& count) {

   138 

   139     if (size < sizeof(uint32_t))

   140         return NO_MEMORY;

   141 

   142     uint32_t flags = 0;

   143     FlattenableUtils::read(buffer, size, flags);

   144 

   145     if (flags & 1) {

   146         mGraphicBuffer = new GraphicBuffer();

   147         status_t err = mGraphicBuffer->unflatten(buffer, size, fds, count);

   148         if (err) return err;

   149         size -= FlattenableUtils::align<4>(buffer);

   150     }

   151 

   152     if (flags & 2) {

   153         mFence = new Fence();

   154         status_t err = mFence->unflatten(buffer, size, fds, count);

   155         if (err) return err;

   156         size -= FlattenableUtils::align<4>(buffer);

   157     }

   158 

   159     // check we have enough space

   160     if (size < getPodSize()) {

   161         return NO_MEMORY;

   162     }

   163 

   164     FlattenableUtils::read(buffer, size, mCrop);

   165     FlattenableUtils::read(buffer, size, mTransform);

   166     FlattenableUtils::read(buffer, size, mScalingMode);

   167     FlattenableUtils::read(buffer, size, mTimestamp);

   168     FlattenableUtils::read(buffer, size, mIsAutoTimestamp);

   169     FlattenableUtils::read(buffer, size, mFrameNumber);

   170     FlattenableUtils::read(buffer, size, mBuf);

   171     FlattenableUtils::read(buffer, size, mIsDroppable);

   172     FlattenableUtils::read(buffer, size, mAcquireCalled);

   173     FlattenableUtils::read(buffer, size, mTransformToDisplayInverse);

   174 

   175     return NO_ERROR;

   176 }

   177 

   178 // ---------------------------------------------------------------------------

   179 

   180 enum {

   181     ACQUIRE_BUFFER = IBinder::FIRST_CALL_TRANSACTION,

   182     RELEASE_BUFFER,

   183     CONSUMER_CONNECT,

   184     CONSUMER_DISCONNECT,

   185     GET_RELEASED_BUFFERS,

   186     SET_DEFAULT_BUFFER_SIZE,

   187     SET_DEFAULT_MAX_BUFFER_COUNT,

   188     DISABLE_ASYNC_BUFFER,

   189     SET_MAX_ACQUIRED_BUFFER_COUNT,

   190     SET_CONSUMER_NAME,

   191     SET_DEFAULT_BUFFER_FORMAT,

   192     SET_CONSUMER_USAGE_BITS,

   193     SET_TRANSFORM_HINT,

   194     DUMP,

   195 };

   196 

   197 class BpGonkGraphicBufferConsumer : public BpInterface<IGonkGraphicBufferConsumer>

   198 {

   199 public:

   200     BpGonkGraphicBufferConsumer(const sp<IBinder>& impl)

   201         : BpInterface<IGonkGraphicBufferConsumer>(impl)

   202     {

   203     }

   204 

   205     virtual status_t acquireBuffer(BufferItem *buffer, nsecs_t presentWhen) {

   206         Parcel data, reply;

   207         data.writeInterfaceToken(IGonkGraphicBufferConsumer::getInterfaceDescriptor());

   208         data.writeInt64(presentWhen);

   209         status_t result = remote()->transact(ACQUIRE_BUFFER, data, &reply);

   210         if (result != NO_ERROR) {

   211             return result;

   212         }

   213         result = reply.read(*buffer);

   214         if (result != NO_ERROR) {

   215             return result;

   216         }

   217         return reply.readInt32();

   218     }

   219 

   220     virtual status_t releaseBuffer(int buf, uint64_t frameNumber,

   221             const sp<Fence>& releaseFence) {

   222         Parcel data, reply;

   223         data.writeInterfaceToken(IGonkGraphicBufferConsumer::getInterfaceDescriptor());

   224         data.writeInt32(buf);

   225         data.writeInt64(frameNumber);

   226         data.write(*releaseFence);

   227         status_t result = remote()->transact(RELEASE_BUFFER, data, &reply);

   228         if (result != NO_ERROR) {

   229             return result;

   230         }

   231         return reply.readInt32();

   232     }

   233 

   234     virtual status_t consumerConnect(const sp<IConsumerListener>& consumer, bool controlledByApp) {

   235         Parcel data, reply;

   236         data.writeInterfaceToken(IGonkGraphicBufferConsumer::getInterfaceDescriptor());

   237         data.writeStrongBinder(consumer->asBinder());

   238         data.writeInt32(controlledByApp);

   239         status_t result = remote()->transact(CONSUMER_CONNECT, data, &reply);

   240         if (result != NO_ERROR) {

   241             return result;

   242         }

   243         return reply.readInt32();

   244     }

   245 

   246     virtual status_t consumerDisconnect() {

   247         Parcel data, reply;

   248         data.writeInterfaceToken(IGonkGraphicBufferConsumer::getInterfaceDescriptor());

   249         status_t result = remote()->transact(CONSUMER_DISCONNECT, data, &reply);

   250         if (result != NO_ERROR) {

   251             return result;

   252         }

   253         return reply.readInt32();

   254     }

   255 

   256     virtual status_t getReleasedBuffers(uint32_t* slotMask) {

   257         Parcel data, reply;

   258         data.writeInterfaceToken(IGonkGraphicBufferConsumer::getInterfaceDescriptor());

   259         status_t result = remote()->transact(GET_RELEASED_BUFFERS, data, &reply);

   260         if (result != NO_ERROR) {

   261             return result;

   262         }

   263         *slotMask = reply.readInt32();

   264         return reply.readInt32();

   265     }

   266 

   267     virtual status_t setDefaultBufferSize(uint32_t w, uint32_t h) {

   268         Parcel data, reply;

   269         data.writeInterfaceToken(IGonkGraphicBufferConsumer::getInterfaceDescriptor());

   270         data.writeInt32(w);

   271         data.writeInt32(h);

   272         status_t result = remote()->transact(SET_DEFAULT_BUFFER_SIZE, data, &reply);

   273         if (result != NO_ERROR) {

   274             return result;

   275         }

   276         return reply.readInt32();

   277     }

   278 

   279     virtual status_t setDefaultMaxBufferCount(int bufferCount) {

   280         Parcel data, reply;

   281         data.writeInterfaceToken(IGonkGraphicBufferConsumer::getInterfaceDescriptor());

   282         data.writeInt32(bufferCount);

   283         status_t result = remote()->transact(SET_DEFAULT_MAX_BUFFER_COUNT, data, &reply);

   284         if (result != NO_ERROR) {

   285             return result;

   286         }

   287         return reply.readInt32();

   288     }

   289 

   290     virtual status_t disableAsyncBuffer() {

   291         Parcel data, reply;

   292         data.writeInterfaceToken(IGonkGraphicBufferConsumer::getInterfaceDescriptor());

   293         status_t result = remote()->transact(DISABLE_ASYNC_BUFFER, data, &reply);

   294         if (result != NO_ERROR) {

   295             return result;

   296         }

   297         return reply.readInt32();

   298     }

   299 

   300     virtual status_t setMaxAcquiredBufferCount(int maxAcquiredBuffers) {

   301         Parcel data, reply;

   302         data.writeInterfaceToken(IGonkGraphicBufferConsumer::getInterfaceDescriptor());

   303         data.writeInt32(maxAcquiredBuffers);

   304         status_t result = remote()->transact(SET_MAX_ACQUIRED_BUFFER_COUNT, data, &reply);

   305         if (result != NO_ERROR) {

   306             return result;

   307         }

   308         return reply.readInt32();

   309     }

   310 

   311     virtual void setConsumerName(const String8& name) {

   312         Parcel data, reply;

   313         data.writeInterfaceToken(IGonkGraphicBufferConsumer::getInterfaceDescriptor());

   314         data.writeString8(name);

   315         remote()->transact(SET_CONSUMER_NAME, data, &reply);

   316     }

   317 

   318     virtual status_t setDefaultBufferFormat(uint32_t defaultFormat) {

   319         Parcel data, reply;

   320         data.writeInterfaceToken(IGonkGraphicBufferConsumer::getInterfaceDescriptor());

   321         data.writeInt32(defaultFormat);

   322         status_t result = remote()->transact(SET_DEFAULT_BUFFER_FORMAT, data, &reply);

   323         if (result != NO_ERROR) {

   324             return result;

   325         }

   326         return reply.readInt32();

   327     }

   328 

   329     virtual status_t setConsumerUsageBits(uint32_t usage) {

   330         Parcel data, reply;

   331         data.writeInterfaceToken(IGonkGraphicBufferConsumer::getInterfaceDescriptor());

   332         data.writeInt32(usage);

   333         status_t result = remote()->transact(SET_CONSUMER_USAGE_BITS, data, &reply);

   334         if (result != NO_ERROR) {

   335             return result;

   336         }

   337         return reply.readInt32();

   338     }

   339 

   340     virtual status_t setTransformHint(uint32_t hint) {

   341         Parcel data, reply;

   342         data.writeInterfaceToken(IGonkGraphicBufferConsumer::getInterfaceDescriptor());

   343         data.writeInt32(hint);

   344         status_t result = remote()->transact(SET_TRANSFORM_HINT, data, &reply);

   345         if (result != NO_ERROR) {

   346             return result;

   347         }

   348         return reply.readInt32();

   349     }

   350 

   351     virtual void dump(String8& result, const char* prefix) const {

   352         Parcel data, reply;

   353         data.writeInterfaceToken(IGonkGraphicBufferConsumer::getInterfaceDescriptor());

   354         data.writeString8(result);

   355         data.writeString8(String8(prefix ? prefix : ""));

   356         remote()->transact(DUMP, data, &reply);

   357         reply.readString8();

   358     }

   359 };

   360 

   361 IMPLEMENT_META_INTERFACE(GonkGraphicBufferConsumer, "android.gui.IGonkGraphicBufferConsumer");

   362 // ----------------------------------------------------------------------

   363 

   364 status_t BnGonkGraphicBufferConsumer::onTransact(

   365         uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)

   366 {

   367     switch(code) {

   368         case ACQUIRE_BUFFER: {

   369             CHECK_INTERFACE(IGonkGraphicBufferConsumer, data, reply);

   370             BufferItem item;

   371             int64_t presentWhen = data.readInt64();

   372             status_t result = acquireBuffer(&item, presentWhen);

   373             status_t err = reply->write(item);

   374             if (err) return err;

   375             reply->writeInt32(result);

   376             return NO_ERROR;

   377         } break;

   378         case RELEASE_BUFFER: {

   379             CHECK_INTERFACE(IGonkGraphicBufferConsumer, data, reply);

   380             int buf = data.readInt32();

   381             uint64_t frameNumber = data.readInt64();

   382             sp<Fence> releaseFence = new Fence();

   383             status_t err = data.read(*releaseFence);

   384             if (err) return err;

   385             status_t result = releaseBuffer(buf, frameNumber, releaseFence);

   386             reply->writeInt32(result);

   387             return NO_ERROR;

   388         } break;

   389 

   390         case CONSUMER_CONNECT: {

   391             CHECK_INTERFACE(IGonkGraphicBufferConsumer, data, reply);

   392             sp<IConsumerListener> consumer = IConsumerListener::asInterface( data.readStrongBinder() );

   393             bool controlledByApp = data.readInt32();

   394             status_t result = consumerConnect(consumer, controlledByApp);

   395             reply->writeInt32(result);

   396             return NO_ERROR;

   397         } break;

   398 

   399         case CONSUMER_DISCONNECT: {

   400             CHECK_INTERFACE(IGonkGraphicBufferConsumer, data, reply);

   401             status_t result = consumerDisconnect();

   402             reply->writeInt32(result);

   403             return NO_ERROR;

   404         } break;

   405         case GET_RELEASED_BUFFERS: {

   406             CHECK_INTERFACE(IGonkGraphicBufferConsumer, data, reply);

   407             uint32_t slotMask;

   408             status_t result = getReleasedBuffers(&slotMask);

   409             reply->writeInt32(slotMask);

   410             reply->writeInt32(result);

   411             return NO_ERROR;

   412         } break;

   413         case SET_DEFAULT_BUFFER_SIZE: {

   414             CHECK_INTERFACE(IGonkGraphicBufferConsumer, data, reply);

   415             uint32_t w = data.readInt32();

   416             uint32_t h = data.readInt32();

   417             status_t result = setDefaultBufferSize(w, h);

   418             reply->writeInt32(result);

   419             return NO_ERROR;

   420         } break;

   421         case SET_DEFAULT_MAX_BUFFER_COUNT: {

   422             CHECK_INTERFACE(IGonkGraphicBufferConsumer, data, reply);

   423             uint32_t bufferCount = data.readInt32();

   424             status_t result = setDefaultMaxBufferCount(bufferCount);

   425             reply->writeInt32(result);

   426             return NO_ERROR;

   427         } break;

   428         case DISABLE_ASYNC_BUFFER: {

   429             CHECK_INTERFACE(IGonkGraphicBufferConsumer, data, reply);

   430             status_t result = disableAsyncBuffer();

   431             reply->writeInt32(result);

   432             return NO_ERROR;

   433         } break;

   434         case SET_MAX_ACQUIRED_BUFFER_COUNT: {

   435             CHECK_INTERFACE(IGonkGraphicBufferConsumer, data, reply);

   436             uint32_t maxAcquiredBuffers = data.readInt32();

   437             status_t result = setMaxAcquiredBufferCount(maxAcquiredBuffers);

   438             reply->writeInt32(result);

   439             return NO_ERROR;

   440         } break;

   441         case SET_CONSUMER_NAME: {

   442             CHECK_INTERFACE(IGonkGraphicBufferConsumer, data, reply);

   443             setConsumerName( data.readString8() );

   444             return NO_ERROR;

   445         } break;

   446         case SET_DEFAULT_BUFFER_FORMAT: {

   447             CHECK_INTERFACE(IGonkGraphicBufferConsumer, data, reply);

   448             uint32_t defaultFormat = data.readInt32();

   449             status_t result = setDefaultBufferFormat(defaultFormat);

   450             reply->writeInt32(result);

   451             return NO_ERROR;

   452         } break;

   453         case SET_CONSUMER_USAGE_BITS: {

   454             CHECK_INTERFACE(IGonkGraphicBufferConsumer, data, reply);

   455             uint32_t usage = data.readInt32();

   456             status_t result = setConsumerUsageBits(usage);

   457             reply->writeInt32(result);

   458             return NO_ERROR;

   459         } break;

   460         case SET_TRANSFORM_HINT: {

   461             CHECK_INTERFACE(IGonkGraphicBufferConsumer, data, reply);

   462             uint32_t hint = data.readInt32();

   463             status_t result = setTransformHint(hint);

   464             reply->writeInt32(result);

   465             return NO_ERROR;

   466         } break;

   467 

   468         case DUMP: {

   469             CHECK_INTERFACE(IGonkGraphicBufferConsumer, data, reply);

   470             String8 result = data.readString8();

   471             String8 prefix = data.readString8();

   472             static_cast<IGonkGraphicBufferConsumer*>(this)->dump(result, prefix);

   473             reply->writeString8(result);

   474             return NO_ERROR;

   475         }

   476     }

   477     return BBinder::onTransact(code, data, reply, flags);

   478 }

   479 

   480 }; // namespace android

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial