Home | History | Annotate | Download | only in gui 
      1 /*
      2  * Copyright (C) 2012 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 #ifndef ANDROID_GUI_BUFFERITEMCONSUMER_H
     18 #define ANDROID_GUI_BUFFERITEMCONSUMER_H
     19 
     20 #include <gui/ConsumerBase.h>
     21 
     22 #include <ui/GraphicBuffer.h>
     23 
     24 #include <utils/String8.h>
     25 #include <utils/Vector.h>
     26 #include <utils/threads.h>
     27 
     28 #define ANDROID_GRAPHICS_BUFFERITEMCONSUMER_JNI_ID "mBufferItemConsumer"
     29 
     30 namespace android {
     31 
     32 class BufferQueue;
     33 
     34 /**
     35  * BufferItemConsumer is a BufferQueue consumer endpoint that allows clients
     36  * access to the whole BufferItem entry from BufferQueue. Multiple buffers may
     37  * be acquired at once, to be used concurrently by the client. This consumer can
     38  * operate either in synchronous or asynchronous mode.
     39  */
     40 class BufferItemConsumer: public ConsumerBase
     41 {
     42   public:
     43     typedef ConsumerBase::FrameAvailableListener FrameAvailableListener;
     44 
     45     typedef BufferQueue::BufferItem BufferItem;
     46 
     47     enum { INVALID_BUFFER_SLOT = BufferQueue::INVALID_BUFFER_SLOT };
     48     enum { NO_BUFFER_AVAILABLE = BufferQueue::NO_BUFFER_AVAILABLE };
     49 
     50     // Create a new buffer item consumer. The consumerUsage parameter determines
     51     // the consumer usage flags passed to the graphics allocator. The
     52     // bufferCount parameter specifies how many buffers can be locked for user
     53     // access at the same time.
     54     // controlledByApp tells whether this consumer is controlled by the
     55     // application.
     56     BufferItemConsumer(const sp<BufferQueue>& bq, uint32_t consumerUsage,
     57             int bufferCount = BufferQueue::MIN_UNDEQUEUED_BUFFERS,
     58             bool controlledByApp = false);
     59 
     60     virtual ~BufferItemConsumer();
     61 
     62     // set the name of the BufferItemConsumer that will be used to identify it in
     63     // log messages.
     64     void setName(const String8& name);
     65 
     66     // Gets the next graphics buffer from the producer, filling out the
     67     // passed-in BufferItem structure. Returns NO_BUFFER_AVAILABLE if the queue
     68     // of buffers is empty, and INVALID_OPERATION if the maximum number of
     69     // buffers is already acquired.
     70     //
     71     // Only a fixed number of buffers can be acquired at a time, determined by
     72     // the construction-time bufferCount parameter. If INVALID_OPERATION is
     73     // returned by acquireBuffer, then old buffers must be returned to the
     74     // queue by calling releaseBuffer before more buffers can be acquired.
     75     //
     76     // If waitForFence is true, and the acquired BufferItem has a valid fence object,
     77     // acquireBuffer will wait on the fence with no timeout before returning.
     78     status_t acquireBuffer(BufferItem *item, nsecs_t presentWhen,
     79         bool waitForFence = true);
     80 
     81     // Returns an acquired buffer to the queue, allowing it to be reused. Since
     82     // only a fixed number of buffers may be acquired at a time, old buffers
     83     // must be released by calling releaseBuffer to ensure new buffers can be
     84     // acquired by acquireBuffer. Once a BufferItem is released, the caller must
     85     // not access any members of the BufferItem, and should immediately remove
     86     // all of its references to the BufferItem itself.
     87     status_t releaseBuffer(const BufferItem &item,
     88             const sp<Fence>& releaseFence = Fence::NO_FENCE);
     89 
     90     // setDefaultBufferSize is used to set the size of buffers returned by
     91     // requestBuffers when a with and height of zero is requested.
     92     status_t setDefaultBufferSize(uint32_t w, uint32_t h);
     93 
     94     // setDefaultBufferFormat allows the BufferQueue to create
     95     // GraphicBuffers of a defaultFormat if no format is specified
     96     // in dequeueBuffer
     97     status_t setDefaultBufferFormat(uint32_t defaultFormat);
     98 };
     99 
    100 } // namespace android
    101 
    102 #endif // ANDROID_GUI_CPUCONSUMER_H
    103