Home | History | Annotate | Download | only in include 
      1 /*
      2  * Copyright (C) 2009 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 OMX_NODE_INSTANCE_H_
     18 
     19 #define OMX_NODE_INSTANCE_H_
     20 
     21 #include "OMX.h"
     22 
     23 #include <utils/RefBase.h>
     24 #include <utils/threads.h>
     25 
     26 namespace android {
     27 
     28 class IOMXObserver;
     29 struct OMXMaster;
     30 class GraphicBufferSource;
     31 
     32 status_t StatusFromOMXError(OMX_ERRORTYPE err);
     33 
     34 struct OMXNodeInstance {
     35     OMXNodeInstance(
     36             OMX *owner, const sp<IOMXObserver> &observer, const char *name);
     37 
     38     void setHandle(OMX::node_id node_id, OMX_HANDLETYPE handle);
     39 
     40     OMX *owner();
     41     sp<IOMXObserver> observer();
     42     OMX::node_id nodeID();
     43 
     44     status_t freeNode(OMXMaster *master);
     45 
     46     status_t sendCommand(OMX_COMMANDTYPE cmd, OMX_S32 param);
     47     status_t getParameter(OMX_INDEXTYPE index, void *params, size_t size);
     48 
     49     status_t setParameter(
     50             OMX_INDEXTYPE index, const void *params, size_t size);
     51 
     52     status_t getConfig(OMX_INDEXTYPE index, void *params, size_t size);
     53     status_t setConfig(OMX_INDEXTYPE index, const void *params, size_t size);
     54 
     55     status_t getState(OMX_STATETYPE* state);
     56 
     57     status_t enableGraphicBuffers(OMX_U32 portIndex, OMX_BOOL enable);
     58 
     59     status_t getGraphicBufferUsage(OMX_U32 portIndex, OMX_U32* usage);
     60 
     61     status_t storeMetaDataInBuffers(
     62             OMX_U32 portIndex, OMX_BOOL enable, MetadataBufferType *type);
     63 
     64     status_t prepareForAdaptivePlayback(
     65             OMX_U32 portIndex, OMX_BOOL enable,
     66             OMX_U32 maxFrameWidth, OMX_U32 maxFrameHeight);
     67 
     68     status_t configureVideoTunnelMode(
     69             OMX_U32 portIndex, OMX_BOOL tunneled,
     70             OMX_U32 audioHwSync, native_handle_t **sidebandHandle);
     71 
     72     status_t useBuffer(
     73             OMX_U32 portIndex, const sp<IMemory> &params,
     74             OMX::buffer_id *buffer, OMX_U32 allottedSize);
     75 
     76     status_t useGraphicBuffer(
     77             OMX_U32 portIndex, const sp<GraphicBuffer> &graphicBuffer,
     78             OMX::buffer_id *buffer);
     79 
     80     status_t updateGraphicBufferInMeta(
     81             OMX_U32 portIndex, const sp<GraphicBuffer> &graphicBuffer,
     82             OMX::buffer_id buffer);
     83 
     84     status_t createInputSurface(
     85             OMX_U32 portIndex, sp<IGraphicBufferProducer> *bufferProducer,
     86             MetadataBufferType *type);
     87 
     88     static status_t createPersistentInputSurface(
     89             sp<IGraphicBufferProducer> *bufferProducer,
     90             sp<IGraphicBufferConsumer> *bufferConsumer);
     91 
     92     status_t setInputSurface(
     93             OMX_U32 portIndex, const sp<IGraphicBufferConsumer> &bufferConsumer,
     94             MetadataBufferType *type);
     95 
     96     status_t signalEndOfInputStream();
     97 
     98     status_t allocateBuffer(
     99             OMX_U32 portIndex, size_t size, OMX::buffer_id *buffer,
    100             void **buffer_data);
    101 
    102     status_t allocateBufferWithBackup(
    103             OMX_U32 portIndex, const sp<IMemory> &params,
    104             OMX::buffer_id *buffer, OMX_U32 allottedSize);
    105 
    106     status_t freeBuffer(OMX_U32 portIndex, OMX::buffer_id buffer);
    107 
    108     status_t fillBuffer(OMX::buffer_id buffer, int fenceFd);
    109 
    110     status_t emptyBuffer(
    111             OMX::buffer_id buffer,
    112             OMX_U32 rangeOffset, OMX_U32 rangeLength,
    113             OMX_U32 flags, OMX_TICKS timestamp, int fenceFd);
    114 
    115     status_t emptyGraphicBuffer(
    116             OMX_BUFFERHEADERTYPE *header, const sp<GraphicBuffer> &buffer,
    117             OMX_U32 flags, OMX_TICKS timestamp, int fenceFd);
    118 
    119     status_t getExtensionIndex(
    120             const char *parameterName, OMX_INDEXTYPE *index);
    121 
    122     status_t setInternalOption(
    123             OMX_U32 portIndex,
    124             IOMX::InternalOptionType type,
    125             const void *data,
    126             size_t size);
    127 
    128     // handles messages and removes them from the list
    129     void onMessages(std::list<omx_message> &messages);
    130     void onMessage(const omx_message &msg);
    131     void onObserverDied(OMXMaster *master);
    132     void onGetHandleFailed();
    133     void onEvent(OMX_EVENTTYPE event, OMX_U32 arg1, OMX_U32 arg2);
    134 
    135     static OMX_CALLBACKTYPE kCallbacks;
    136 
    137 private:
    138     Mutex mLock;
    139 
    140     OMX *mOwner;
    141     OMX::node_id mNodeID;
    142     OMX_HANDLETYPE mHandle;
    143     sp<IOMXObserver> mObserver;
    144     bool mDying;
    145 
    146     // Lock only covers mGraphicBufferSource.  We can't always use mLock
    147     // because of rare instances where we'd end up locking it recursively.
    148     Mutex mGraphicBufferSourceLock;
    149     // Access this through getGraphicBufferSource().
    150     sp<GraphicBufferSource> mGraphicBufferSource;
    151 
    152 
    153     struct ActiveBuffer {
    154         OMX_U32 mPortIndex;
    155         OMX::buffer_id mID;
    156     };
    157     Vector<ActiveBuffer> mActiveBuffers;
    158     // for buffer ptr to buffer id translation
    159     Mutex mBufferIDLock;
    160     uint32_t mBufferIDCount;
    161     KeyedVector<OMX::buffer_id, OMX_BUFFERHEADERTYPE *> mBufferIDToBufferHeader;
    162     KeyedVector<OMX_BUFFERHEADERTYPE *, OMX::buffer_id> mBufferHeaderToBufferID;
    163     MetadataBufferType mMetadataType[2];
    164 
    165     // For debug support
    166     char *mName;
    167     int DEBUG;
    168     size_t mNumPortBuffers[2];  // modified under mLock, read outside for debug
    169     Mutex mDebugLock;
    170     // following are modified and read under mDebugLock
    171     int DEBUG_BUMP;
    172     SortedVector<OMX_BUFFERHEADERTYPE *> mInputBuffersWithCodec, mOutputBuffersWithCodec;
    173     size_t mDebugLevelBumpPendingBuffers[2];
    174     void bumpDebugLevel_l(size_t numInputBuffers, size_t numOutputBuffers);
    175     void unbumpDebugLevel_l(size_t portIndex);
    176 
    177     ~OMXNodeInstance();
    178 
    179     void addActiveBuffer(OMX_U32 portIndex, OMX::buffer_id id);
    180     void removeActiveBuffer(OMX_U32 portIndex, OMX::buffer_id id);
    181     void freeActiveBuffers();
    182 
    183     // For buffer id management
    184     OMX::buffer_id makeBufferID(OMX_BUFFERHEADERTYPE *bufferHeader);
    185     OMX_BUFFERHEADERTYPE *findBufferHeader(OMX::buffer_id buffer);
    186     OMX::buffer_id findBufferID(OMX_BUFFERHEADERTYPE *bufferHeader);
    187     void invalidateBufferID(OMX::buffer_id buffer);
    188 
    189     status_t useGraphicBuffer2_l(
    190             OMX_U32 portIndex, const sp<GraphicBuffer> &graphicBuffer,
    191             OMX::buffer_id *buffer);
    192     static OMX_ERRORTYPE OnEvent(
    193             OMX_IN OMX_HANDLETYPE hComponent,
    194             OMX_IN OMX_PTR pAppData,
    195             OMX_IN OMX_EVENTTYPE eEvent,
    196             OMX_IN OMX_U32 nData1,
    197             OMX_IN OMX_U32 nData2,
    198             OMX_IN OMX_PTR pEventData);
    199 
    200     static OMX_ERRORTYPE OnEmptyBufferDone(
    201             OMX_IN OMX_HANDLETYPE hComponent,
    202             OMX_IN OMX_PTR pAppData,
    203             OMX_IN OMX_BUFFERHEADERTYPE *pBuffer);
    204 
    205     static OMX_ERRORTYPE OnFillBufferDone(
    206             OMX_IN OMX_HANDLETYPE hComponent,
    207             OMX_IN OMX_PTR pAppData,
    208             OMX_IN OMX_BUFFERHEADERTYPE *pBuffer);
    209 
    210     status_t storeMetaDataInBuffers_l(
    211             OMX_U32 portIndex, OMX_BOOL enable, MetadataBufferType *type);
    212 
    213     // Stores fence into buffer if it is ANWBuffer type and has enough space.
    214     // otherwise, waits for the fence to signal.  Takes ownership of |fenceFd|.
    215     status_t storeFenceInMeta_l(
    216             OMX_BUFFERHEADERTYPE *header, int fenceFd, OMX_U32 portIndex);
    217 
    218     // Retrieves the fence from buffer if ANWBuffer type and has enough space. Otherwise, returns -1
    219     int retrieveFenceFromMeta_l(
    220             OMX_BUFFERHEADERTYPE *header, OMX_U32 portIndex);
    221 
    222     status_t emptyBuffer_l(
    223             OMX_BUFFERHEADERTYPE *header,
    224             OMX_U32 flags, OMX_TICKS timestamp, intptr_t debugAddr, int fenceFd);
    225 
    226     status_t updateGraphicBufferInMeta_l(
    227             OMX_U32 portIndex, const sp<GraphicBuffer> &graphicBuffer,
    228             OMX::buffer_id buffer, OMX_BUFFERHEADERTYPE *header);
    229 
    230     status_t createGraphicBufferSource(
    231             OMX_U32 portIndex, sp<IGraphicBufferConsumer> consumer /* nullable */,
    232             MetadataBufferType *type);
    233     sp<GraphicBufferSource> getGraphicBufferSource();
    234     void setGraphicBufferSource(const sp<GraphicBufferSource>& bufferSource);
    235 
    236     // Handles |msg|, and may modify it. Returns true iff completely handled it and
    237     // |msg| does not need to be sent to the event listener.
    238     bool handleMessage(omx_message &msg);
    239 
    240     OMXNodeInstance(const OMXNodeInstance &);
    241     OMXNodeInstance &operator=(const OMXNodeInstance &);
    242 };
    243 
    244 }  // namespace android
    245 
    246 #endif  // OMX_NODE_INSTANCE_H_
    247