IOMX.h revision 8f7f7ad54c698cb57a2a369cf1ae5b917853917b 
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 ANDROID_IOMX_H_
18
19#define ANDROID_IOMX_H_
20
21#include <binder/IInterface.h>
22#include <ui/GraphicBuffer.h>
23#include <utils/List.h>
24#include <utils/String8.h>
25
26#include <OMX_Core.h>
27#include <OMX_Video.h>
28
29namespace android {
30
31class IMemory;
32class IOMXObserver;
33class IOMXRenderer;
34class Surface;
35
36class IOMX : public IInterface {
37public:
38    DECLARE_META_INTERFACE(OMX);
39
40    typedef void *buffer_id;
41    typedef void *node_id;
42
43    // Given a node_id and the calling process' pid, returns true iff
44    // the implementation of the OMX interface lives in the same
45    // process.
46    virtual bool livesLocally(node_id node, pid_t pid) = 0;
47
48    struct ComponentInfo {
49        String8 mName;
50        List<String8> mRoles;
51    };
52    virtual status_t listNodes(List<ComponentInfo> *list) = 0;
53
54    virtual status_t allocateNode(
55            const char *name, const sp<IOMXObserver> &observer,
56            node_id *node) = 0;
57
58    virtual status_t freeNode(node_id node) = 0;
59
60    virtual status_t sendCommand(
61            node_id node, OMX_COMMANDTYPE cmd, OMX_S32 param) = 0;
62
63    virtual status_t getParameter(
64            node_id node, OMX_INDEXTYPE index,
65            void *params, size_t size) = 0;
66
67    virtual status_t setParameter(
68            node_id node, OMX_INDEXTYPE index,
69            const void *params, size_t size) = 0;
70
71    virtual status_t getConfig(
72            node_id node, OMX_INDEXTYPE index,
73            void *params, size_t size) = 0;
74
75    virtual status_t setConfig(
76            node_id node, OMX_INDEXTYPE index,
77            const void *params, size_t size) = 0;
78
79    virtual status_t getState(
80            node_id node, OMX_STATETYPE* state) = 0;
81
82    virtual status_t storeMetaDataInBuffers(
83            node_id node, OMX_U32 port_index, OMX_BOOL enable) = 0;
84
85    virtual status_t enableGraphicBuffers(
86            node_id node, OMX_U32 port_index, OMX_BOOL enable) = 0;
87
88    virtual status_t getGraphicBufferUsage(
89            node_id node, OMX_U32 port_index, OMX_U32* usage) = 0;
90
91    virtual status_t useBuffer(
92            node_id node, OMX_U32 port_index, const sp<IMemory> &params,
93            buffer_id *buffer) = 0;
94
95    virtual status_t useGraphicBuffer(
96            node_id node, OMX_U32 port_index,
97            const sp<GraphicBuffer> &graphicBuffer, buffer_id *buffer) = 0;
98
99    // This API clearly only makes sense if the caller lives in the
100    // same process as the callee, i.e. is the media_server, as the
101    // returned "buffer_data" pointer is just that, a pointer into local
102    // address space.
103    virtual status_t allocateBuffer(
104            node_id node, OMX_U32 port_index, size_t size,
105            buffer_id *buffer, void **buffer_data) = 0;
106
107    virtual status_t allocateBufferWithBackup(
108            node_id node, OMX_U32 port_index, const sp<IMemory> &params,
109            buffer_id *buffer) = 0;
110
111    virtual status_t freeBuffer(
112            node_id node, OMX_U32 port_index, buffer_id buffer) = 0;
113
114    virtual status_t fillBuffer(node_id node, buffer_id buffer) = 0;
115
116    virtual status_t emptyBuffer(
117            node_id node,
118            buffer_id buffer,
119            OMX_U32 range_offset, OMX_U32 range_length,
120            OMX_U32 flags, OMX_TICKS timestamp) = 0;
121
122    virtual status_t getExtensionIndex(
123            node_id node,
124            const char *parameter_name,
125            OMX_INDEXTYPE *index) = 0;
126};
127
128struct omx_message {
129    enum {
130        EVENT,
131        EMPTY_BUFFER_DONE,
132        FILL_BUFFER_DONE,
133
134    } type;
135
136    IOMX::node_id node;
137
138    union {
139        // if type == EVENT
140        struct {
141            OMX_EVENTTYPE event;
142            OMX_U32 data1;
143            OMX_U32 data2;
144        } event_data;
145
146        // if type == EMPTY_BUFFER_DONE
147        struct {
148            IOMX::buffer_id buffer;
149        } buffer_data;
150
151        // if type == FILL_BUFFER_DONE
152        struct {
153            IOMX::buffer_id buffer;
154            OMX_U32 range_offset;
155            OMX_U32 range_length;
156            OMX_U32 flags;
157            OMX_TICKS timestamp;
158            OMX_PTR platform_private;
159            OMX_PTR data_ptr;
160        } extended_buffer_data;
161
162    } u;
163};
164
165class IOMXObserver : public IInterface {
166public:
167    DECLARE_META_INTERFACE(OMXObserver);
168
169    virtual void onMessage(const omx_message &msg) = 0;
170};
171
172////////////////////////////////////////////////////////////////////////////////
173
174class BnOMX : public BnInterface<IOMX> {
175public:
176    virtual status_t onTransact(
177            uint32_t code, const Parcel &data, Parcel *reply,
178            uint32_t flags = 0);
179};
180
181class BnOMXObserver : public BnInterface<IOMXObserver> {
182public:
183    virtual status_t onTransact(
184            uint32_t code, const Parcel &data, Parcel *reply,
185            uint32_t flags = 0);
186};
187
188struct CodecProfileLevel {
189    OMX_U32 mProfile;
190    OMX_U32 mLevel;
191};
192
193}  // namespace android
194
195#endif  // ANDROID_IOMX_H_
196