IGraphicBufferProducer.h revision b687a2814ca9db576eb1ea33dea90ac35cd61bc1
18ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis/* 28ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis * Copyright (C) 2010 The Android Open Source Project 38ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis * 48ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis * Licensed under the Apache License, Version 2.0 (the "License"); 58ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis * you may not use this file except in compliance with the License. 68ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis * You may obtain a copy of the License at 78ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis * 88ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis * http://www.apache.org/licenses/LICENSE-2.0 98ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis * 108ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis * Unless required by applicable law or agreed to in writing, software 118ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis * distributed under the License is distributed on an "AS IS" BASIS, 128ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 138ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis * See the License for the specific language governing permissions and 148ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis * limitations under the License. 158ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis */ 168ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis 172adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFadden#ifndef ANDROID_GUI_IGRAPHICBUFFERPRODUCER_H 182adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFadden#define ANDROID_GUI_IGRAPHICBUFFERPRODUCER_H 198ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis 208ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis#include <stdint.h> 218ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis#include <sys/types.h> 228ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis 238ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis#include <utils/Errors.h> 248ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis#include <utils/RefBase.h> 258ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis 268ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis#include <binder/IInterface.h> 278ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis 28f78575400977f644cf0b12beb2fa5fc278b6ed4cJesse Hall#include <ui/Fence.h> 298ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis#include <ui/GraphicBuffer.h> 308ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis#include <ui/Rect.h> 315065a55291b67f584d7b0be3fa3cfc4e29a3cd1cDan Stoza#include <ui/Region.h> 328ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis 338ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennisnamespace android { 348ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis// ---------------------------------------------------------------------------- 358ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis 36f0eaf25e9247edf4d124bedaeb863f7abdf35a3eDan Stozaclass IProducerListener; 37399184a4cd728ea1421fb0bc1722274a29e38f4aJesse Hallclass NativeHandle; 38e3c697fb929c856b59fa56a8e05a2a7eba187c3dMathias Agopianclass Surface; 39eafabcdc1639fb96062d9e3c39b0ae27b0238ae1Mathias Agopian 400273adbf0bc202eda2ca579ae0773464ea9c701fAndy McFadden/* 41466a192d2088f9238d34597d1aa28da41367c1caAndy McFadden * This class defines the Binder IPC interface for the producer side of 42466a192d2088f9238d34597d1aa28da41367c1caAndy McFadden * a queue of graphics buffers. It's used to send graphics data from one 43466a192d2088f9238d34597d1aa28da41367c1caAndy McFadden * component to another. For example, a class that decodes video for 44466a192d2088f9238d34597d1aa28da41367c1caAndy McFadden * playback might use this to provide frames. This is typically done 45e3c697fb929c856b59fa56a8e05a2a7eba187c3dMathias Agopian * indirectly, through Surface. 460273adbf0bc202eda2ca579ae0773464ea9c701fAndy McFadden * 47466a192d2088f9238d34597d1aa28da41367c1caAndy McFadden * The underlying mechanism is a BufferQueue, which implements 48466a192d2088f9238d34597d1aa28da41367c1caAndy McFadden * BnGraphicBufferProducer. In normal operation, the producer calls 49466a192d2088f9238d34597d1aa28da41367c1caAndy McFadden * dequeueBuffer() to get an empty buffer, fills it with data, then 50466a192d2088f9238d34597d1aa28da41367c1caAndy McFadden * calls queueBuffer() to make it available to the consumer. 510273adbf0bc202eda2ca579ae0773464ea9c701fAndy McFadden * 522adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFadden * This class was previously called ISurfaceTexture. 530273adbf0bc202eda2ca579ae0773464ea9c701fAndy McFadden */ 542adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFaddenclass IGraphicBufferProducer : public IInterface 558ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis{ 568ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennispublic: 572adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFadden DECLARE_META_INTERFACE(GraphicBufferProducer); 588ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis 598072711307aa98ee5ee6f7369860ae38c3e19656Mathias Agopian enum { 607d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // A flag returned by dequeueBuffer when the client needs to call 617d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // requestBuffer immediately thereafter. 628072711307aa98ee5ee6f7369860ae38c3e19656Mathias Agopian BUFFER_NEEDS_REALLOCATION = 0x1, 637d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // A flag returned by dequeueBuffer when all mirrored slots should be 647d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // released by the client. This flag should always be processed first. 658072711307aa98ee5ee6f7369860ae38c3e19656Mathias Agopian RELEASE_ALL_BUFFERS = 0x2, 668072711307aa98ee5ee6f7369860ae38c3e19656Mathias Agopian }; 67a5c75c01620179ce00812354778a29a80d76e71fMathias Agopian 688ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis // requestBuffer requests a new buffer for the given index. The server (i.e. 692adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFadden // the IGraphicBufferProducer implementation) assigns the newly created 702adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFadden // buffer to the given slot index, and the client is expected to mirror the 718ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis // slot->buffer mapping so that it's not necessary to transfer a 728ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis // GraphicBuffer for every dequeue operation. 737d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 747d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // The slot must be in the range of [0, NUM_BUFFER_SLOTS). 757d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 767d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // Return of a value other than NO_ERROR means an error has occurred: 77583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // * NO_INIT - the buffer queue has been abandoned or the producer is not 78583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // connected. 797d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * BAD_VALUE - one of the two conditions occurred: 807d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * slot was out of range (see above) 817d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * buffer specified by the slot is not dequeued 827b305fffc39d0fe0926e7fd2d7f6a524fbce62b7Jamie Gennis virtual status_t requestBuffer(int slot, sp<GraphicBuffer>* buf) = 0; 838ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis 84fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // setMaxDequeuedBufferCount sets the maximum number of buffers that can be 85fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // dequeued by the producer at one time. If this method succeeds, buffer 86fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // slots will be both unallocated and owned by the BufferQueue object (i.e. 87fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // they are not owned by the producer or consumer). Calling this will also 88fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // cause all buffer slots to be emptied. If the caller is caching the 89fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // contents of the buffer slots, it should empty that cache after calling 90fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // this method. 91fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // 92fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // This function should not be called when there are any currently dequeued 93fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // buffer slots. Doing so will result in a BAD_VALUE error. 94fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // 95fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // The buffer count should be at least 1 (inclusive), but at most 96fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // (NUM_BUFFER_SLOTS - the minimum undequeued buffer count) (exclusive). The 97fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // minimum undequeued buffer count can be obtained by calling 98fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // query(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS). 99fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // 100fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // Return of a value other than NO_ERROR means an error has occurred: 101fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // * NO_INIT - the buffer queue has been abandoned. 102fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // * BAD_VALUE - one of the below conditions occurred: 10319e3e06e3c65a7c001a6fe0971744ba5ff536515Pablo Ceballos // * bufferCount was out of range (see above) 10419e3e06e3c65a7c001a6fe0971744ba5ff536515Pablo Ceballos // * client has one or more buffers dequeued 10519e3e06e3c65a7c001a6fe0971744ba5ff536515Pablo Ceballos // * this call would cause the maxBufferCount value to be exceeded 106fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos virtual status_t setMaxDequeuedBufferCount(int maxDequeuedBuffers) = 0; 107fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos 108fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // Set the async flag if the producer intends to asynchronously queue 109fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // buffers without blocking. Typically this is used for triple-buffering 110fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // and/or when the swap interval is set to zero. 111fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // 112fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // Enabling async mode will internally allocate an additional buffer to 113fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // allow for the asynchronous behavior. If it is not enabled queue/dequeue 114fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // calls may block. 115fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // 116fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // Return of a value other than NO_ERROR means an error has occurred: 117fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos // * NO_INIT - the buffer queue has been abandoned. 118b687a2814ca9db576eb1ea33dea90ac35cd61bc1Pablo Ceballos // * BAD_VALUE - this call would cause the maxBufferCount value to be 119b687a2814ca9db576eb1ea33dea90ac35cd61bc1Pablo Ceballos // exceeded 120fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos virtual status_t setAsyncMode(bool async) = 0; 121fa455354557f6283ff3a7d76979e52fd251c155fPablo Ceballos 1228ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis // dequeueBuffer requests a new buffer slot for the client to use. Ownership 1238ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis // of the slot is transfered to the client, meaning that the server will not 1247d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // use the contents of the buffer associated with that slot. 1257d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 1267d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // The slot index returned may or may not contain a buffer (client-side). 1277d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // If the slot is empty the client should call requestBuffer to assign a new 1287d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // buffer to that slot. 1297d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 1307d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // Once the client is done filling this buffer, it is expected to transfer 1317d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // buffer ownership back to the server with either cancelBuffer on 1327d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // the dequeued slot or to fill in the contents of its associated buffer 1337d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // contents and call queueBuffer. 1347d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 1357d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // If dequeueBuffer returns the BUFFER_NEEDS_REALLOCATION flag, the client is 136a5c75c01620179ce00812354778a29a80d76e71fMathias Agopian // expected to call requestBuffer immediately. 137f78575400977f644cf0b12beb2fa5fc278b6ed4cJesse Hall // 1387d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // If dequeueBuffer returns the RELEASE_ALL_BUFFERS flag, the client is 1397d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // expected to release all of the mirrored slot->buffer mappings. 1407d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 141f78575400977f644cf0b12beb2fa5fc278b6ed4cJesse Hall // The fence parameter will be updated to hold the fence associated with 142f78575400977f644cf0b12beb2fa5fc278b6ed4cJesse Hall // the buffer. The contents of the buffer must not be overwritten until the 1437d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // fence signals. If the fence is Fence::NO_FENCE, the buffer may be written 144f78575400977f644cf0b12beb2fa5fc278b6ed4cJesse Hall // immediately. 1457cdd786fa80cf03551291ae8feca7b77583be1c5Mathias Agopian // 1467d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // The width and height parameters must be no greater than the minimum of 1477d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // GL_MAX_VIEWPORT_DIMS and GL_MAX_TEXTURE_SIZE (see: glGetIntegerv). 1487d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // An error due to invalid dimensions might not be reported until 1497d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // updateTexImage() is called. If width and height are both zero, the 1507d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // default values specified by setDefaultBufferSize() are used instead. 1517d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 1523be1c6b60a188dc10025e2ce156c11fac050625dDan Stoza // If the format is 0, the default format will be used. 1537d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 1547d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // The usage argument specifies gralloc buffer usage flags. The values 1557d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // are enumerated in <gralloc.h>, e.g. GRALLOC_USAGE_HW_RENDER. These 1567d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // will be merged with the usage flags specified by 1577d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // IGraphicBufferConsumer::setConsumerUsageBits. 1587d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 1597d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // This call will block until a buffer is available to be dequeued. If 1607d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // both the producer and consumer are controlled by the app, then this call 1617d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // can never block and will return WOULD_BLOCK if no buffer is available. 1627d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 1637d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // A non-negative value with flags set (see above) will be returned upon 1647d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // success. 1657d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 1667d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // Return of a negative means an error has occurred: 167583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // * NO_INIT - the buffer queue has been abandoned or the producer is not 168583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // connected. 1699f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // * BAD_VALUE - both in async mode and buffer count was less than the 1709f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // max numbers of buffers that can be allocated at once. 1719f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // * INVALID_OPERATION - cannot attach the buffer because it would cause 1729f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // too many buffers to be dequeued, either because 1739f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // the producer already has a single buffer dequeued 1749f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // and did not set a buffer count, or because a 1759f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // buffer count was set and this call would cause 1769f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // it to be exceeded. 1777d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * WOULD_BLOCK - no buffer is currently available, and blocking is disabled 1787d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // since both the producer/consumer are controlled by app 1797d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * NO_MEMORY - out of memory, cannot allocate the graphics buffer. 1807d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 1817d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // All other negative values are an unknown error returned downstream 1827d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // from the graphics allocator (typically errno). 183567dbbb6dd42be5013fcde0dadb3316d85f2fa0dPablo Ceballos virtual status_t dequeueBuffer(int* slot, sp<Fence>* fence, uint32_t w, 184567dbbb6dd42be5013fcde0dadb3316d85f2fa0dPablo Ceballos uint32_t h, PixelFormat format, uint32_t usage) = 0; 1858ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis 1869f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // detachBuffer attempts to remove all ownership of the buffer in the given 1879f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // slot from the buffer queue. If this call succeeds, the slot will be 1889f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // freed, and there will be no way to obtain the buffer from this interface. 1899f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // The freed slot will remain unallocated until either it is selected to 1909f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // hold a freshly allocated buffer in dequeueBuffer or a buffer is attached 1919f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // to the slot. The buffer must have already been dequeued, and the caller 1929f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // must already possesses the sp<GraphicBuffer> (i.e., must have called 1939f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // requestBuffer). 1949f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // 1959f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // Return of a value other than NO_ERROR means an error has occurred: 196583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // * NO_INIT - the buffer queue has been abandoned or the producer is not 197583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // connected. 1989f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // * BAD_VALUE - the given slot number is invalid, either because it is 1999f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // out of the range [0, NUM_BUFFER_SLOTS), or because the slot 2009f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // it refers to is not currently dequeued and requested. 2019f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza virtual status_t detachBuffer(int slot) = 0; 2029f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza 203d9822a3843017444364899afc3c23fb5be6b9cb9Dan Stoza // detachNextBuffer is equivalent to calling dequeueBuffer, requestBuffer, 204d9822a3843017444364899afc3c23fb5be6b9cb9Dan Stoza // and detachBuffer in sequence, except for two things: 205d9822a3843017444364899afc3c23fb5be6b9cb9Dan Stoza // 206d9822a3843017444364899afc3c23fb5be6b9cb9Dan Stoza // 1) It is unnecessary to know the dimensions, format, or usage of the 207d9822a3843017444364899afc3c23fb5be6b9cb9Dan Stoza // next buffer. 208d9822a3843017444364899afc3c23fb5be6b9cb9Dan Stoza // 2) It will not block, since if it cannot find an appropriate buffer to 209d9822a3843017444364899afc3c23fb5be6b9cb9Dan Stoza // return, it will return an error instead. 210d9822a3843017444364899afc3c23fb5be6b9cb9Dan Stoza // 211d9822a3843017444364899afc3c23fb5be6b9cb9Dan Stoza // Only slots that are free but still contain a GraphicBuffer will be 212d9822a3843017444364899afc3c23fb5be6b9cb9Dan Stoza // considered, and the oldest of those will be returned. outBuffer is 213d9822a3843017444364899afc3c23fb5be6b9cb9Dan Stoza // equivalent to outBuffer from the requestBuffer call, and outFence is 214d9822a3843017444364899afc3c23fb5be6b9cb9Dan Stoza // equivalent to fence from the dequeueBuffer call. 215d9822a3843017444364899afc3c23fb5be6b9cb9Dan Stoza // 216d9822a3843017444364899afc3c23fb5be6b9cb9Dan Stoza // Return of a value other than NO_ERROR means an error has occurred: 217583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // * NO_INIT - the buffer queue has been abandoned or the producer is not 218583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // connected. 219d9822a3843017444364899afc3c23fb5be6b9cb9Dan Stoza // * BAD_VALUE - either outBuffer or outFence were NULL. 220d9822a3843017444364899afc3c23fb5be6b9cb9Dan Stoza // * NO_MEMORY - no slots were found that were both free and contained a 221d9822a3843017444364899afc3c23fb5be6b9cb9Dan Stoza // GraphicBuffer. 222d9822a3843017444364899afc3c23fb5be6b9cb9Dan Stoza virtual status_t detachNextBuffer(sp<GraphicBuffer>* outBuffer, 223d9822a3843017444364899afc3c23fb5be6b9cb9Dan Stoza sp<Fence>* outFence) = 0; 224d9822a3843017444364899afc3c23fb5be6b9cb9Dan Stoza 2259f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // attachBuffer attempts to transfer ownership of a buffer to the buffer 2269f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // queue. If this call succeeds, it will be as if this buffer was dequeued 2279f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // from the returned slot number. As such, this call will fail if attaching 2289f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // this buffer would cause too many buffers to be simultaneously dequeued. 2299f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // 2309f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // If attachBuffer returns the RELEASE_ALL_BUFFERS flag, the caller is 2319f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // expected to release all of the mirrored slot->buffer mappings. 2329f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // 2339f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // A non-negative value with flags set (see above) will be returned upon 2349f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // success. 2359f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // 2369f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // Return of a negative value means an error has occurred: 237583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // * NO_INIT - the buffer queue has been abandoned or the producer is not 238583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // connected. 239812ed0644f8f8f71ca403f4e5793f0dbc1fcf9b2Dan Stoza // * BAD_VALUE - outSlot or buffer were NULL, invalid combination of 240812ed0644f8f8f71ca403f4e5793f0dbc1fcf9b2Dan Stoza // async mode and buffer count override, or the generation 241812ed0644f8f8f71ca403f4e5793f0dbc1fcf9b2Dan Stoza // number of the buffer did not match the buffer queue. 2429f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // * INVALID_OPERATION - cannot attach the buffer because it would cause 2439f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // too many buffers to be dequeued, either because 2449f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // the producer already has a single buffer dequeued 2459f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // and did not set a buffer count, or because a 2469f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // buffer count was set and this call would cause 2479f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // it to be exceeded. 2489f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // * WOULD_BLOCK - no buffer slot is currently available, and blocking is 2499f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // disabled since both the producer/consumer are 2509f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza // controlled by the app. 2519f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza virtual status_t attachBuffer(int* outSlot, 2529f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza const sp<GraphicBuffer>& buffer) = 0; 2539f3053de78630815d60cf48a2cf2348cc5867c45Dan Stoza 2548ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis // queueBuffer indicates that the client has finished filling in the 2558ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis // contents of the buffer associated with slot and transfers ownership of 2567d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // that slot back to the server. 2577d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 2587d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // It is not valid to call queueBuffer on a slot that is not owned 2597d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // by the client or one for which a buffer associated via requestBuffer 2607d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // (an attempt to do so will fail with a return value of BAD_VALUE). 2617d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 2627d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // In addition, the input must be described by the client (as documented 2637d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // below). Any other properties (zero point, etc) 2641d01a12e7150be569557b64da9b8663c62c13594Eino-Ville Talvala // are client-dependent, and should be documented by the client. 26597c602c5af5f3ffd69009bf496d86347b71a2b4cMathias Agopian // 2667d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // The slot must be in the range of [0, NUM_BUFFER_SLOTS). 2677d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 2687d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // Upon success, the output will be filled with meaningful values 2697d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // (refer to the documentation below). 2707cdd786fa80cf03551291ae8feca7b77583be1c5Mathias Agopian // 2717d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // Return of a value other than NO_ERROR means an error has occurred: 272583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // * NO_INIT - the buffer queue has been abandoned or the producer is not 273583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // connected. 2747d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * BAD_VALUE - one of the below conditions occurred: 2757d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * fence was NULL 2767d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * scaling mode was unknown 2777d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * both in async mode and buffer count was less than the 2787d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // max numbers of buffers that can be allocated at once 2797d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * slot index was out of range (see above). 2807d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * the slot was not in the dequeued state 2817d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * the slot was enqueued without requesting a buffer 2827d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * crop rect is out of bounds of the buffer dimensions 283f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian 284e142428a9c8b9d2380032cd4d7b55ee440fe8770Mathias Agopian struct QueueBufferInput : public Flattenable<QueueBufferInput> { 285e142428a9c8b9d2380032cd4d7b55ee440fe8770Mathias Agopian friend class Flattenable<QueueBufferInput>; 286c777b0b3b9b0ea5d8e378fccde6935765e28e329Jesse Hall inline QueueBufferInput(const Parcel& parcel); 2877d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // timestamp - a monotonically increasing value in nanoseconds 2887d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // isAutoTimestamp - if the timestamp was synthesized at queue time 28982c6bcc9705eabcaf5b9e45bc81867b0e2d61a02Eino-Ville Talvala // dataSpace - description of the contents, interpretation depends on format 2907d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // crop - a crop rectangle that's used as a hint to the consumer 2917d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // scalingMode - a set of flags from NATIVE_WINDOW_SCALING_* in <window.h> 2927d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // transform - a set of flags from NATIVE_WINDOW_TRANSFORM_* in <window.h> 2937d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // fence - a fence that the consumer must wait on before reading the buffer, 2947d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // set this to Fence::NO_FENCE if the buffer is ready immediately 2951681d95989271f3a9ac0dbb93d10e4a29f2b4444Ruben Brunk // sticky - the sticky transform set in Surface (only used by the LEGACY 2961681d95989271f3a9ac0dbb93d10e4a29f2b4444Ruben Brunk // camera mode). 2973c25621ad7d13f64d3ab95a27fa970fbc9998f73Andy McFadden inline QueueBufferInput(int64_t timestamp, bool isAutoTimestamp, 29882c6bcc9705eabcaf5b9e45bc81867b0e2d61a02Eino-Ville Talvala android_dataspace dataSpace, const Rect& crop, int scalingMode, 299567dbbb6dd42be5013fcde0dadb3316d85f2fa0dPablo Ceballos uint32_t transform, const sp<Fence>& fence, uint32_t sticky = 0) 30082c6bcc9705eabcaf5b9e45bc81867b0e2d61a02Eino-Ville Talvala : timestamp(timestamp), isAutoTimestamp(isAutoTimestamp), 30182c6bcc9705eabcaf5b9e45bc81867b0e2d61a02Eino-Ville Talvala dataSpace(dataSpace), crop(crop), scalingMode(scalingMode), 302567dbbb6dd42be5013fcde0dadb3316d85f2fa0dPablo Ceballos transform(transform), stickyTransform(sticky), fence(fence), 303567dbbb6dd42be5013fcde0dadb3316d85f2fa0dPablo Ceballos surfaceDamage() { } 3043c25621ad7d13f64d3ab95a27fa970fbc9998f73Andy McFadden inline void deflate(int64_t* outTimestamp, bool* outIsAutoTimestamp, 30582c6bcc9705eabcaf5b9e45bc81867b0e2d61a02Eino-Ville Talvala android_dataspace* outDataSpace, 30682c6bcc9705eabcaf5b9e45bc81867b0e2d61a02Eino-Ville Talvala Rect* outCrop, int* outScalingMode, 307567dbbb6dd42be5013fcde0dadb3316d85f2fa0dPablo Ceballos uint32_t* outTransform, sp<Fence>* outFence, 3081681d95989271f3a9ac0dbb93d10e4a29f2b4444Ruben Brunk uint32_t* outStickyTransform = NULL) const { 309f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian *outTimestamp = timestamp; 3103c25621ad7d13f64d3ab95a27fa970fbc9998f73Andy McFadden *outIsAutoTimestamp = bool(isAutoTimestamp); 31182c6bcc9705eabcaf5b9e45bc81867b0e2d61a02Eino-Ville Talvala *outDataSpace = dataSpace; 312f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian *outCrop = crop; 313f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian *outScalingMode = scalingMode; 314f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian *outTransform = transform; 315c777b0b3b9b0ea5d8e378fccde6935765e28e329Jesse Hall *outFence = fence; 3161681d95989271f3a9ac0dbb93d10e4a29f2b4444Ruben Brunk if (outStickyTransform != NULL) { 3171681d95989271f3a9ac0dbb93d10e4a29f2b4444Ruben Brunk *outStickyTransform = stickyTransform; 3181681d95989271f3a9ac0dbb93d10e4a29f2b4444Ruben Brunk } 319f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian } 320c777b0b3b9b0ea5d8e378fccde6935765e28e329Jesse Hall 321e142428a9c8b9d2380032cd4d7b55ee440fe8770Mathias Agopian // Flattenable protocol 322e142428a9c8b9d2380032cd4d7b55ee440fe8770Mathias Agopian size_t getFlattenedSize() const; 323e142428a9c8b9d2380032cd4d7b55ee440fe8770Mathias Agopian size_t getFdCount() const; 324e142428a9c8b9d2380032cd4d7b55ee440fe8770Mathias Agopian status_t flatten(void*& buffer, size_t& size, int*& fds, size_t& count) const; 325e142428a9c8b9d2380032cd4d7b55ee440fe8770Mathias Agopian status_t unflatten(void const*& buffer, size_t& size, int const*& fds, size_t& count); 326c777b0b3b9b0ea5d8e378fccde6935765e28e329Jesse Hall 3275065a55291b67f584d7b0be3fa3cfc4e29a3cd1cDan Stoza const Region& getSurfaceDamage() const { return surfaceDamage; } 3285065a55291b67f584d7b0be3fa3cfc4e29a3cd1cDan Stoza void setSurfaceDamage(const Region& damage) { surfaceDamage = damage; } 3295065a55291b67f584d7b0be3fa3cfc4e29a3cd1cDan Stoza 330f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian private: 331f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian int64_t timestamp; 3323c25621ad7d13f64d3ab95a27fa970fbc9998f73Andy McFadden int isAutoTimestamp; 33382c6bcc9705eabcaf5b9e45bc81867b0e2d61a02Eino-Ville Talvala android_dataspace dataSpace; 334f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian Rect crop; 335f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian int scalingMode; 336f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian uint32_t transform; 3371681d95989271f3a9ac0dbb93d10e4a29f2b4444Ruben Brunk uint32_t stickyTransform; 338c777b0b3b9b0ea5d8e378fccde6935765e28e329Jesse Hall sp<Fence> fence; 3395065a55291b67f584d7b0be3fa3cfc4e29a3cd1cDan Stoza Region surfaceDamage; 340f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian }; 341f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian 342f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian // QueueBufferOutput must be a POD structure 3437d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin struct __attribute__ ((__packed__)) QueueBufferOutput { 344f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian inline QueueBufferOutput() { } 3457d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // outWidth - filled with default width applied to the buffer 3467d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // outHeight - filled with default height applied to the buffer 3477d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // outTransformHint - filled with default transform applied to the buffer 3487d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // outNumPendingBuffers - num buffers queued that haven't yet been acquired 3497d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // (counting the currently queued buffer) 350f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian inline void deflate(uint32_t* outWidth, 3512488b20aec097accb20a853d9876bb0a5dc04636Mathias Agopian uint32_t* outHeight, 3522488b20aec097accb20a853d9876bb0a5dc04636Mathias Agopian uint32_t* outTransformHint, 3532488b20aec097accb20a853d9876bb0a5dc04636Mathias Agopian uint32_t* outNumPendingBuffers) const { 354f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian *outWidth = width; 355f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian *outHeight = height; 356f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian *outTransformHint = transformHint; 3572488b20aec097accb20a853d9876bb0a5dc04636Mathias Agopian *outNumPendingBuffers = numPendingBuffers; 358f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian } 359f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian inline void inflate(uint32_t inWidth, uint32_t inHeight, 3602488b20aec097accb20a853d9876bb0a5dc04636Mathias Agopian uint32_t inTransformHint, uint32_t inNumPendingBuffers) { 361f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian width = inWidth; 362f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian height = inHeight; 363f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian transformHint = inTransformHint; 3642488b20aec097accb20a853d9876bb0a5dc04636Mathias Agopian numPendingBuffers = inNumPendingBuffers; 365f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian } 366f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian private: 367f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian uint32_t width; 368f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian uint32_t height; 369f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian uint32_t transformHint; 3702488b20aec097accb20a853d9876bb0a5dc04636Mathias Agopian uint32_t numPendingBuffers; 371f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian }; 372f0bc2f1d8d37977bd3aef3d3326a70e9e69d4246Mathias Agopian 373567dbbb6dd42be5013fcde0dadb3316d85f2fa0dPablo Ceballos virtual status_t queueBuffer(int slot, const QueueBufferInput& input, 374567dbbb6dd42be5013fcde0dadb3316d85f2fa0dPablo Ceballos QueueBufferOutput* output) = 0; 3758ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis 3768ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis // cancelBuffer indicates that the client does not wish to fill in the 3778ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis // buffer associated with slot and transfers ownership of the slot back to 3788ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis // the server. 3797d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 3807d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // The buffer is not queued for use by the consumer. 3817d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 382583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // The slot must be in the range of [0, NUM_BUFFER_SLOTS). 383583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // 3847d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // The buffer will not be overwritten until the fence signals. The fence 3857d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // will usually be the one obtained from dequeueBuffer. 386583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // 387583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // Return of a value other than NO_ERROR means an error has occurred: 388583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // * NO_INIT - the buffer queue has been abandoned or the producer is not 389583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // connected. 390583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // * BAD_VALUE - one of the below conditions occurred: 391583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // * fence was NULL 392583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // * slot index was out of range (see above). 393583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos // * the slot was not in the dequeued state 394583b1b32191992d6ada58b3c61c71932a71c0c4bPablo Ceballos virtual status_t cancelBuffer(int slot, const sp<Fence>& fence) = 0; 3958ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis 396eafabcdc1639fb96062d9e3c39b0ae27b0238ae1Mathias Agopian // query retrieves some information for this surface 3977d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 'what' tokens allowed are that of NATIVE_WINDOW_* in <window.h> 3987d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 3997d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // Return of a value other than NO_ERROR means an error has occurred: 4007d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * NO_INIT - the buffer queue has been abandoned. 4017d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * BAD_VALUE - what was out of range 402eafabcdc1639fb96062d9e3c39b0ae27b0238ae1Mathias Agopian virtual int query(int what, int* value) = 0; 4038072711307aa98ee5ee6f7369860ae38c3e19656Mathias Agopian 4042adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFadden // connect attempts to connect a client API to the IGraphicBufferProducer. 4052adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFadden // This must be called before any other IGraphicBufferProducer methods are 4067d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // called except for getAllocator. A consumer must be already connected. 407fe0a87b54654a1392650e7f1862df473287d8332Jamie Gennis // 408fe0a87b54654a1392650e7f1862df473287d8332Jamie Gennis // This method will fail if the connect was previously called on the 4092adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFadden // IGraphicBufferProducer and no corresponding disconnect call was made. 4105bfc24515bb5c8ea7975f72d538df37753733a2fMathias Agopian // 411f0eaf25e9247edf4d124bedaeb863f7abdf35a3eDan Stoza // The listener is an optional binder callback object that can be used if 412f0eaf25e9247edf4d124bedaeb863f7abdf35a3eDan Stoza // the producer wants to be notified when the consumer releases a buffer 413f0eaf25e9247edf4d124bedaeb863f7abdf35a3eDan Stoza // back to the BufferQueue. It is also used to detect the death of the 414f0eaf25e9247edf4d124bedaeb863f7abdf35a3eDan Stoza // producer. If only the latter functionality is desired, there is a 415f0eaf25e9247edf4d124bedaeb863f7abdf35a3eDan Stoza // DummyProducerListener class in IProducerListener.h that can be used. 4167d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 4177d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // The api should be one of the NATIVE_WINDOW_API_* values in <window.h> 4187d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 4197d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // The producerControlledByApp should be set to true if the producer is hosted 4207d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // by an untrusted process (typically app_process-forked processes). If both 4217d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // the producer and the consumer are app-controlled then all buffer queues 4227d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // will operate in async mode regardless of the async flag. 4237d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 4247d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // Upon success, the output will be filled with meaningful data 4257d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // (refer to QueueBufferOutput documentation above). 4267d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 4277d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // Return of a value other than NO_ERROR means an error has occurred: 4287d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * NO_INIT - one of the following occurred: 4297d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * the buffer queue was abandoned 4307d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * no consumer has yet connected 4317d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * BAD_VALUE - one of the following has occurred: 4327d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * the producer is already connected 4337d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * api was out of range (see above). 4347ea777f097784492f880623067becac1b276f884Igor Murashkin // * output was NULL. 4357d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * DEAD_OBJECT - the token is hosted by an already-dead process 4367d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 4377d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // Additional negative errors may be returned by the internals, they 4387d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // should be treated as opaque fatal unrecoverable errors. 439f0eaf25e9247edf4d124bedaeb863f7abdf35a3eDan Stoza virtual status_t connect(const sp<IProducerListener>& listener, 440365857df8b94c959dea984a63013f6e7730ef976Mathias Agopian int api, bool producerControlledByApp, QueueBufferOutput* output) = 0; 441fe0a87b54654a1392650e7f1862df473287d8332Jamie Gennis 4422adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFadden // disconnect attempts to disconnect a client API from the 4432adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFadden // IGraphicBufferProducer. Calling this method will cause any subsequent 4442adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFadden // calls to other IGraphicBufferProducer methods to fail except for 4452adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFadden // getAllocator and connect. Successfully calling connect after this will 4462adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFadden // allow the other methods to succeed again. 447fe0a87b54654a1392650e7f1862df473287d8332Jamie Gennis // 4482adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFadden // This method will fail if the the IGraphicBufferProducer is not currently 449fe0a87b54654a1392650e7f1862df473287d8332Jamie Gennis // connected to the specified client API. 4507d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 4517d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // The api should be one of the NATIVE_WINDOW_API_* values in <window.h> 4527d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 4537d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // Disconnecting from an abandoned IGraphicBufferProducer is legal and 4547d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // is considered a no-op. 4557d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // 4567d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // Return of a value other than NO_ERROR means an error has occurred: 4577d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * BAD_VALUE - one of the following has occurred: 4587d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * the api specified does not match the one that was connected 4597d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * api was out of range (see above). 4607d2d160cdc3cba9f4454f38433c94b68376cb843Igor Murashkin // * DEAD_OBJECT - the token is hosted by an already-dead process 461fe0a87b54654a1392650e7f1862df473287d8332Jamie Gennis virtual status_t disconnect(int api) = 0; 462399184a4cd728ea1421fb0bc1722274a29e38f4aJesse Hall 463399184a4cd728ea1421fb0bc1722274a29e38f4aJesse Hall // Attaches a sideband buffer stream to the IGraphicBufferProducer. 464399184a4cd728ea1421fb0bc1722274a29e38f4aJesse Hall // 465399184a4cd728ea1421fb0bc1722274a29e38f4aJesse Hall // A sideband stream is a device-specific mechanism for passing buffers 466399184a4cd728ea1421fb0bc1722274a29e38f4aJesse Hall // from the producer to the consumer without using dequeueBuffer/ 467399184a4cd728ea1421fb0bc1722274a29e38f4aJesse Hall // queueBuffer. If a sideband stream is present, the consumer can choose 468399184a4cd728ea1421fb0bc1722274a29e38f4aJesse Hall // whether to acquire buffers from the sideband stream or from the queued 469399184a4cd728ea1421fb0bc1722274a29e38f4aJesse Hall // buffers. 470399184a4cd728ea1421fb0bc1722274a29e38f4aJesse Hall // 471399184a4cd728ea1421fb0bc1722274a29e38f4aJesse Hall // Passing NULL or a different stream handle will detach the previous 472399184a4cd728ea1421fb0bc1722274a29e38f4aJesse Hall // handle if any. 473399184a4cd728ea1421fb0bc1722274a29e38f4aJesse Hall virtual status_t setSidebandStream(const sp<NativeHandle>& stream) = 0; 47429a3e90879fd96404c971e7187cd0e05927bbce0Dan Stoza 47529a3e90879fd96404c971e7187cd0e05927bbce0Dan Stoza // Allocates buffers based on the given dimensions/format. 47629a3e90879fd96404c971e7187cd0e05927bbce0Dan Stoza // 47729a3e90879fd96404c971e7187cd0e05927bbce0Dan Stoza // This function will allocate up to the maximum number of buffers 47829a3e90879fd96404c971e7187cd0e05927bbce0Dan Stoza // permitted by the current BufferQueue configuration. It will use the 47929a3e90879fd96404c971e7187cd0e05927bbce0Dan Stoza // given format, dimensions, and usage bits, which are interpreted in the 48029a3e90879fd96404c971e7187cd0e05927bbce0Dan Stoza // same way as for dequeueBuffer, and the async flag must be set the same 48129a3e90879fd96404c971e7187cd0e05927bbce0Dan Stoza // way as for dequeueBuffer to ensure that the correct number of buffers are 48229a3e90879fd96404c971e7187cd0e05927bbce0Dan Stoza // allocated. This is most useful to avoid an allocation delay during 48329a3e90879fd96404c971e7187cd0e05927bbce0Dan Stoza // dequeueBuffer. If there are already the maximum number of buffers 48429a3e90879fd96404c971e7187cd0e05927bbce0Dan Stoza // allocated, this function has no effect. 485567dbbb6dd42be5013fcde0dadb3316d85f2fa0dPablo Ceballos virtual void allocateBuffers(uint32_t width, uint32_t height, 4863be1c6b60a188dc10025e2ce156c11fac050625dDan Stoza PixelFormat format, uint32_t usage) = 0; 4879de7293b0a1b01ebe6fb1ab4a498f144adc8029fDan Stoza 4889de7293b0a1b01ebe6fb1ab4a498f144adc8029fDan Stoza // Sets whether dequeueBuffer is allowed to allocate new buffers. 4899de7293b0a1b01ebe6fb1ab4a498f144adc8029fDan Stoza // 4909de7293b0a1b01ebe6fb1ab4a498f144adc8029fDan Stoza // Normally dequeueBuffer does not discriminate between free slots which 4919de7293b0a1b01ebe6fb1ab4a498f144adc8029fDan Stoza // already have an allocated buffer and those which do not, and will 4929de7293b0a1b01ebe6fb1ab4a498f144adc8029fDan Stoza // allocate a new buffer if the slot doesn't have a buffer or if the slot's 4939de7293b0a1b01ebe6fb1ab4a498f144adc8029fDan Stoza // buffer doesn't match the requested size, format, or usage. This method 4949de7293b0a1b01ebe6fb1ab4a498f144adc8029fDan Stoza // allows the producer to restrict the eligible slots to those which already 4959de7293b0a1b01ebe6fb1ab4a498f144adc8029fDan Stoza // have an allocated buffer of the correct size, format, and usage. If no 4969de7293b0a1b01ebe6fb1ab4a498f144adc8029fDan Stoza // eligible slot is available, dequeueBuffer will block or return an error 4979de7293b0a1b01ebe6fb1ab4a498f144adc8029fDan Stoza // as usual. 4989de7293b0a1b01ebe6fb1ab4a498f144adc8029fDan Stoza virtual status_t allowAllocation(bool allow) = 0; 499812ed0644f8f8f71ca403f4e5793f0dbc1fcf9b2Dan Stoza 500812ed0644f8f8f71ca403f4e5793f0dbc1fcf9b2Dan Stoza // Sets the current generation number of the BufferQueue. 501812ed0644f8f8f71ca403f4e5793f0dbc1fcf9b2Dan Stoza // 502812ed0644f8f8f71ca403f4e5793f0dbc1fcf9b2Dan Stoza // This generation number will be inserted into any buffers allocated by the 503812ed0644f8f8f71ca403f4e5793f0dbc1fcf9b2Dan Stoza // BufferQueue, and any attempts to attach a buffer with a different 504812ed0644f8f8f71ca403f4e5793f0dbc1fcf9b2Dan Stoza // generation number will fail. Buffers already in the queue are not 505812ed0644f8f8f71ca403f4e5793f0dbc1fcf9b2Dan Stoza // affected and will retain their current generation number. The generation 506812ed0644f8f8f71ca403f4e5793f0dbc1fcf9b2Dan Stoza // number defaults to 0. 507812ed0644f8f8f71ca403f4e5793f0dbc1fcf9b2Dan Stoza virtual status_t setGenerationNumber(uint32_t generationNumber) = 0; 508c6f30bdee1f634eb90d68cb76efe935b6535a1e8Dan Stoza 509c6f30bdee1f634eb90d68cb76efe935b6535a1e8Dan Stoza // Returns the name of the connected consumer. 510c6f30bdee1f634eb90d68cb76efe935b6535a1e8Dan Stoza virtual String8 getConsumerName() const = 0; 5118ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis}; 5128ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis 5138ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis// ---------------------------------------------------------------------------- 5148ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis 5152adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFaddenclass BnGraphicBufferProducer : public BnInterface<IGraphicBufferProducer> 5168ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis{ 5178ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennispublic: 5188ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis virtual status_t onTransact( uint32_t code, 5198ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis const Parcel& data, 5208ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis Parcel* reply, 5218ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis uint32_t flags = 0); 5228ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis}; 5238ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis 5248ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis// ---------------------------------------------------------------------------- 5258ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis}; // namespace android 5268ba32fade11abb73f3fd47ea0953c9528eb5b91fJamie Gennis 5272adaf04fab35cf47c824d74d901b54094e01ccd3Andy McFadden#endif // ANDROID_GUI_IGRAPHICBUFFERPRODUCER_H 528