295 lines
10 KiB
C++
295 lines
10 KiB
C++
/*
|
|
* Copyright (C) 2009 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifndef ANDROID_IOMX_H_
|
|
|
|
#define ANDROID_IOMX_H_
|
|
|
|
#include <binder/IInterface.h>
|
|
#include <gui/IGraphicBufferProducer.h>
|
|
#include <gui/IGraphicBufferConsumer.h>
|
|
#include <ui/GraphicBuffer.h>
|
|
#include <utils/List.h>
|
|
#include <utils/String8.h>
|
|
|
|
#include <list>
|
|
|
|
#include <media/hardware/MetadataBufferType.h>
|
|
|
|
#include <OMX_Core.h>
|
|
#include <OMX_Video.h>
|
|
|
|
namespace android {
|
|
|
|
class IMemory;
|
|
class IOMXObserver;
|
|
class IOMXRenderer;
|
|
class NativeHandle;
|
|
class Surface;
|
|
|
|
class IOMX : public IInterface {
|
|
public:
|
|
DECLARE_META_INTERFACE(OMX);
|
|
|
|
typedef uint32_t buffer_id;
|
|
typedef uint32_t node_id;
|
|
|
|
// Given a node_id and the calling process' pid, returns true iff
|
|
// the implementation of the OMX interface lives in the same
|
|
// process.
|
|
virtual bool livesLocally(node_id node, pid_t pid) = 0;
|
|
|
|
struct ComponentInfo {
|
|
String8 mName;
|
|
List<String8> mRoles;
|
|
};
|
|
virtual status_t listNodes(List<ComponentInfo> *list) = 0;
|
|
|
|
virtual status_t allocateNode(
|
|
const char *name, const sp<IOMXObserver> &observer,
|
|
sp<IBinder> *nodeBinder,
|
|
node_id *node) = 0;
|
|
|
|
virtual status_t freeNode(node_id node) = 0;
|
|
|
|
virtual status_t sendCommand(
|
|
node_id node, OMX_COMMANDTYPE cmd, OMX_S32 param) = 0;
|
|
|
|
virtual status_t getParameter(
|
|
node_id node, OMX_INDEXTYPE index,
|
|
void *params, size_t size) = 0;
|
|
|
|
virtual status_t setParameter(
|
|
node_id node, OMX_INDEXTYPE index,
|
|
const void *params, size_t size) = 0;
|
|
|
|
virtual status_t getConfig(
|
|
node_id node, OMX_INDEXTYPE index,
|
|
void *params, size_t size) = 0;
|
|
|
|
virtual status_t setConfig(
|
|
node_id node, OMX_INDEXTYPE index,
|
|
const void *params, size_t size) = 0;
|
|
|
|
virtual status_t getState(
|
|
node_id node, OMX_STATETYPE* state) = 0;
|
|
|
|
// This will set *type to previous metadata buffer type on OMX error (not on binder error), and
|
|
// new metadata buffer type on success.
|
|
virtual status_t storeMetaDataInBuffers(
|
|
node_id node, OMX_U32 port_index, OMX_BOOL enable, MetadataBufferType *type = NULL) = 0;
|
|
|
|
virtual status_t prepareForAdaptivePlayback(
|
|
node_id node, OMX_U32 portIndex, OMX_BOOL enable,
|
|
OMX_U32 maxFrameWidth, OMX_U32 maxFrameHeight) = 0;
|
|
|
|
virtual status_t configureVideoTunnelMode(
|
|
node_id node, OMX_U32 portIndex, OMX_BOOL tunneled,
|
|
OMX_U32 audioHwSync, native_handle_t **sidebandHandle) = 0;
|
|
|
|
virtual status_t enableNativeBuffers(
|
|
node_id node, OMX_U32 port_index, OMX_BOOL graphic, OMX_BOOL enable) = 0;
|
|
|
|
virtual status_t getGraphicBufferUsage(
|
|
node_id node, OMX_U32 port_index, OMX_U32* usage) = 0;
|
|
|
|
// Use |params| as an OMX buffer, but limit the size of the OMX buffer to |allottedSize|.
|
|
virtual status_t useBuffer(
|
|
node_id node, OMX_U32 port_index, const sp<IMemory> ¶ms,
|
|
buffer_id *buffer, OMX_U32 allottedSize) = 0;
|
|
|
|
virtual status_t useGraphicBuffer(
|
|
node_id node, OMX_U32 port_index,
|
|
const sp<GraphicBuffer> &graphicBuffer, buffer_id *buffer) = 0;
|
|
|
|
virtual status_t updateGraphicBufferInMeta(
|
|
node_id node, OMX_U32 port_index,
|
|
const sp<GraphicBuffer> &graphicBuffer, buffer_id buffer) = 0;
|
|
|
|
virtual status_t updateNativeHandleInMeta(
|
|
node_id node, OMX_U32 port_index,
|
|
const sp<NativeHandle> &nativeHandle, buffer_id buffer) = 0;
|
|
|
|
// This will set *type to resulting metadata buffer type on OMX error (not on binder error) as
|
|
// well as on success.
|
|
virtual status_t createInputSurface(
|
|
node_id node, OMX_U32 port_index, android_dataspace dataSpace,
|
|
sp<IGraphicBufferProducer> *bufferProducer,
|
|
MetadataBufferType *type = NULL) = 0;
|
|
|
|
virtual status_t createPersistentInputSurface(
|
|
sp<IGraphicBufferProducer> *bufferProducer,
|
|
sp<IGraphicBufferConsumer> *bufferConsumer) = 0;
|
|
|
|
// This will set *type to resulting metadata buffer type on OMX error (not on binder error) as
|
|
// well as on success.
|
|
virtual status_t setInputSurface(
|
|
node_id node, OMX_U32 port_index,
|
|
const sp<IGraphicBufferConsumer> &bufferConsumer,
|
|
MetadataBufferType *type) = 0;
|
|
|
|
virtual status_t signalEndOfInputStream(node_id node) = 0;
|
|
|
|
// Allocate an opaque buffer as a native handle. If component supports returning native
|
|
// handles, those are returned in *native_handle. Otherwise, the allocated buffer is
|
|
// returned in *buffer_data. This clearly only makes sense if the caller lives in the
|
|
// same process as the callee, i.e. is the media_server, as the returned "buffer_data"
|
|
// pointer is just that, a pointer into local address space.
|
|
virtual status_t allocateSecureBuffer(
|
|
node_id node, OMX_U32 port_index, size_t size,
|
|
buffer_id *buffer, void **buffer_data, sp<NativeHandle> *native_handle) = 0;
|
|
|
|
// Allocate an OMX buffer of size |allotedSize|. Use |params| as the backup buffer, which
|
|
// may be larger.
|
|
virtual status_t allocateBufferWithBackup(
|
|
node_id node, OMX_U32 port_index, const sp<IMemory> ¶ms,
|
|
buffer_id *buffer, OMX_U32 allottedSize) = 0;
|
|
|
|
virtual status_t freeBuffer(
|
|
node_id node, OMX_U32 port_index, buffer_id buffer) = 0;
|
|
|
|
enum {
|
|
kFenceTimeoutMs = 1000
|
|
};
|
|
// Calls OMX_FillBuffer on buffer, and passes |fenceFd| to component if it supports
|
|
// fences. Otherwise, it waits on |fenceFd| before calling OMX_FillBuffer.
|
|
// Takes ownership of |fenceFd| even if this call fails.
|
|
virtual status_t fillBuffer(node_id node, buffer_id buffer, int fenceFd = -1) = 0;
|
|
|
|
// Calls OMX_EmptyBuffer on buffer (after updating buffer header with |range_offset|,
|
|
// |range_length|, |flags| and |timestamp|). Passes |fenceFd| to component if it
|
|
// supports fences. Otherwise, it waits on |fenceFd| before calling OMX_EmptyBuffer.
|
|
// Takes ownership of |fenceFd| even if this call fails.
|
|
virtual status_t emptyBuffer(
|
|
node_id node,
|
|
buffer_id buffer,
|
|
OMX_U32 range_offset, OMX_U32 range_length,
|
|
OMX_U32 flags, OMX_TICKS timestamp, int fenceFd = -1) = 0;
|
|
|
|
virtual status_t getExtensionIndex(
|
|
node_id node,
|
|
const char *parameter_name,
|
|
OMX_INDEXTYPE *index) = 0;
|
|
|
|
enum InternalOptionType {
|
|
INTERNAL_OPTION_SUSPEND, // data is a bool
|
|
INTERNAL_OPTION_REPEAT_PREVIOUS_FRAME_DELAY, // data is an int64_t
|
|
INTERNAL_OPTION_MAX_TIMESTAMP_GAP, // data is int64_t
|
|
INTERNAL_OPTION_MAX_FPS, // data is float
|
|
INTERNAL_OPTION_START_TIME, // data is an int64_t
|
|
INTERNAL_OPTION_TIME_LAPSE, // data is an int64_t[2]
|
|
INTERNAL_OPTION_COLOR_ASPECTS, // data is ColorAspects
|
|
INTERNAL_OPTION_TIME_OFFSET, // data is an int64_t
|
|
};
|
|
virtual status_t setInternalOption(
|
|
node_id node,
|
|
OMX_U32 port_index,
|
|
InternalOptionType type,
|
|
const void *data,
|
|
size_t size) = 0;
|
|
};
|
|
|
|
struct omx_message {
|
|
enum {
|
|
EVENT,
|
|
EMPTY_BUFFER_DONE,
|
|
FILL_BUFFER_DONE,
|
|
FRAME_RENDERED,
|
|
} type;
|
|
|
|
IOMX::node_id node;
|
|
int fenceFd; // used for EMPTY_BUFFER_DONE and FILL_BUFFER_DONE; client must close this
|
|
|
|
union {
|
|
// if type == EVENT
|
|
struct {
|
|
OMX_EVENTTYPE event;
|
|
OMX_U32 data1;
|
|
OMX_U32 data2;
|
|
} event_data;
|
|
|
|
// if type == EMPTY_BUFFER_DONE
|
|
struct {
|
|
IOMX::buffer_id buffer;
|
|
} buffer_data;
|
|
|
|
// if type == FILL_BUFFER_DONE
|
|
struct {
|
|
IOMX::buffer_id buffer;
|
|
OMX_U32 range_offset;
|
|
OMX_U32 range_length;
|
|
OMX_U32 flags;
|
|
OMX_TICKS timestamp;
|
|
} extended_buffer_data;
|
|
|
|
// if type == FRAME_RENDERED
|
|
struct {
|
|
OMX_TICKS timestamp;
|
|
OMX_S64 nanoTime;
|
|
} render_data;
|
|
} u;
|
|
};
|
|
|
|
class IOMXObserver : public IInterface {
|
|
public:
|
|
DECLARE_META_INTERFACE(OMXObserver);
|
|
|
|
// Handle (list of) messages.
|
|
virtual void onMessages(const std::list<omx_message> &messages) = 0;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
class BnOMX : public BnInterface<IOMX> {
|
|
public:
|
|
virtual status_t onTransact(
|
|
uint32_t code, const Parcel &data, Parcel *reply,
|
|
uint32_t flags = 0);
|
|
|
|
protected:
|
|
// check if the codec is secure.
|
|
virtual bool isSecure(IOMX::node_id node) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class BnOMXObserver : public BnInterface<IOMXObserver> {
|
|
public:
|
|
virtual status_t onTransact(
|
|
uint32_t code, const Parcel &data, Parcel *reply,
|
|
uint32_t flags = 0);
|
|
};
|
|
|
|
struct CodecProfileLevel {
|
|
OMX_U32 mProfile;
|
|
OMX_U32 mLevel;
|
|
};
|
|
|
|
inline static const char *asString(MetadataBufferType i, const char *def = "??") {
|
|
using namespace android;
|
|
switch (i) {
|
|
case kMetadataBufferTypeCameraSource: return "CameraSource";
|
|
case kMetadataBufferTypeGrallocSource: return "GrallocSource";
|
|
case kMetadataBufferTypeANWBuffer: return "ANWBuffer";
|
|
case kMetadataBufferTypeNativeHandleSource: return "NativeHandleSource";
|
|
case kMetadataBufferTypeInvalid: return "Invalid";
|
|
default: return def;
|
|
}
|
|
}
|
|
|
|
} // namespace android
|
|
|
|
#endif // ANDROID_IOMX_H_
|