include/media/IOMX.h - android_frameworks_av - Gitiles

 /*
  * 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 <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 IGraphicBufferProducer;
 class IGraphicBufferSource;
 class IMemory;
 class IOMXBufferSource;
 class IOMXNode;
 class IOMXObserver;
 class NativeHandle;
 struct omx_message;

 class IOMX : public IInterface {
 public:
     DECLARE_META_INTERFACE(OMX);

     typedef uint32_t buffer_id;

     enum {
         kFenceTimeoutMs = 1000
     };

     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<IOMXNode> *omxNode) = 0;

     virtual status_t createInputSurface(
             sp<IGraphicBufferProducer> *bufferProducer,
             sp<IGraphicBufferSource> *bufferSource) = 0;
 };

 class IOMXNode : public IInterface {
 public:
     DECLARE_META_INTERFACE(OMXNode);

     typedef IOMX::buffer_id buffer_id;

     virtual status_t freeNode() = 0;

     virtual status_t sendCommand(
             OMX_COMMANDTYPE cmd, OMX_S32 param) = 0;

     virtual status_t getParameter(
             OMX_INDEXTYPE index, void *params, size_t size) = 0;

     virtual status_t setParameter(
             OMX_INDEXTYPE index, const void *params, size_t size) = 0;

     virtual status_t getConfig(
             OMX_INDEXTYPE index, void *params, size_t size) = 0;

     virtual status_t setConfig(
             OMX_INDEXTYPE index, const void *params, size_t size) = 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(
             OMX_U32 port_index, OMX_BOOL enable, MetadataBufferType *type = NULL) = 0;

     virtual status_t prepareForAdaptivePlayback(
             OMX_U32 portIndex, OMX_BOOL enable,
             OMX_U32 maxFrameWidth, OMX_U32 maxFrameHeight) = 0;

     virtual status_t configureVideoTunnelMode(
             OMX_U32 portIndex, OMX_BOOL tunneled,
             OMX_U32 audioHwSync, native_handle_t **sidebandHandle) = 0;

     virtual status_t enableNativeBuffers(
             OMX_U32 port_index, OMX_BOOL graphic, OMX_BOOL enable) = 0;

     virtual status_t getGraphicBufferUsage(
             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(
             OMX_U32 port_index, const sp<IMemory> &params,
             buffer_id *buffer, OMX_U32 allottedSize) = 0;

     virtual status_t useGraphicBuffer(
             OMX_U32 port_index,
             const sp<GraphicBuffer> &graphicBuffer, buffer_id *buffer) = 0;

     virtual status_t updateGraphicBufferInMeta(
             OMX_U32 port_index,
             const sp<GraphicBuffer> &graphicBuffer, buffer_id buffer) = 0;

     virtual status_t updateNativeHandleInMeta(
             OMX_U32 port_index,
             const sp<NativeHandle> &nativeHandle, buffer_id buffer) = 0;

     virtual status_t setInputSurface(
             const sp<IOMXBufferSource> &bufferSource) = 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(
             OMX_U32 port_index, size_t size, buffer_id *buffer,
             void **buffer_data, sp<NativeHandle> *native_handle) = 0;

     virtual status_t freeBuffer(
             OMX_U32 port_index, buffer_id buffer) = 0;

     // 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(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(
             buffer_id buffer,
             OMX_U32 range_offset, OMX_U32 range_length,
             OMX_U32 flags, OMX_TICKS timestamp, int fenceFd = -1) = 0;

     // Calls OMX_EmptyBuffer on buffer (after updating buffer header with metadata of
     // |graphicBuffer|, |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. If |origTimestamp| >= 0,
     // timestamp on the filled buffer corresponding to this frame will be modified to
     // |origTimestamp| after it's filled.
     virtual status_t emptyGraphicBuffer(
             buffer_id buffer,
             const sp<GraphicBuffer> &graphicBuffer, OMX_U32 flags,
             OMX_TICKS timestamp, OMX_TICKS origTimestamp, int fenceFd) = 0;

     virtual status_t getExtensionIndex(
             const char *parameter_name,
             OMX_INDEXTYPE *index) = 0;

     virtual status_t dispatchMessage(const omx_message &msg) = 0;

     // TODO: this is temporary, will be removed when quirks move to OMX side
     virtual status_t setQuirks(OMX_U32 quirks) = 0;
 };

 struct omx_message {
     enum {
         EVENT,
         EMPTY_BUFFER_DONE,
         FILL_BUFFER_DONE,
         FRAME_RENDERED,
     } type;

     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;
             OMX_U32 data3;
             OMX_U32 data4;
         } 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);
 };

 class BnOMXNode : public BnInterface<IOMXNode> {
 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() const {
         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_
	/*
	* 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 <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 IGraphicBufferProducer;
	class IGraphicBufferSource;
	class IMemory;
	class IOMXBufferSource;
	class IOMXNode;
	class IOMXObserver;
	class NativeHandle;
	struct omx_message;

	class IOMX : public IInterface {
	public:
	DECLARE_META_INTERFACE(OMX);

	typedef uint32_t buffer_id;

	enum {
	kFenceTimeoutMs = 1000
	};

	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<IOMXNode> *omxNode) = 0;

	virtual status_t createInputSurface(
	sp<IGraphicBufferProducer> *bufferProducer,
	sp<IGraphicBufferSource> *bufferSource) = 0;
	};

	class IOMXNode : public IInterface {
	public:
	DECLARE_META_INTERFACE(OMXNode);

	typedef IOMX::buffer_id buffer_id;

	virtual status_t freeNode() = 0;

	virtual status_t sendCommand(
	OMX_COMMANDTYPE cmd, OMX_S32 param) = 0;

	virtual status_t getParameter(
	OMX_INDEXTYPE index, void *params, size_t size) = 0;

	virtual status_t setParameter(
	OMX_INDEXTYPE index, const void *params, size_t size) = 0;

	virtual status_t getConfig(
	OMX_INDEXTYPE index, void *params, size_t size) = 0;

	virtual status_t setConfig(
	OMX_INDEXTYPE index, const void *params, size_t size) = 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(
	OMX_U32 port_index, OMX_BOOL enable, MetadataBufferType *type = NULL) = 0;

	virtual status_t prepareForAdaptivePlayback(
	OMX_U32 portIndex, OMX_BOOL enable,
	OMX_U32 maxFrameWidth, OMX_U32 maxFrameHeight) = 0;

	virtual status_t configureVideoTunnelMode(
	OMX_U32 portIndex, OMX_BOOL tunneled,
	OMX_U32 audioHwSync, native_handle_t **sidebandHandle) = 0;

	virtual status_t enableNativeBuffers(
	OMX_U32 port_index, OMX_BOOL graphic, OMX_BOOL enable) = 0;

	virtual status_t getGraphicBufferUsage(
	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(
	OMX_U32 port_index, const sp<IMemory> &params,
	buffer_id *buffer, OMX_U32 allottedSize) = 0;

	virtual status_t useGraphicBuffer(
	OMX_U32 port_index,
	const sp<GraphicBuffer> &graphicBuffer, buffer_id *buffer) = 0;

	virtual status_t updateGraphicBufferInMeta(
	OMX_U32 port_index,
	const sp<GraphicBuffer> &graphicBuffer, buffer_id buffer) = 0;

	virtual status_t updateNativeHandleInMeta(
	OMX_U32 port_index,
	const sp<NativeHandle> &nativeHandle, buffer_id buffer) = 0;

	virtual status_t setInputSurface(
	const sp<IOMXBufferSource> &bufferSource) = 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(
	OMX_U32 port_index, size_t size, buffer_id *buffer,
	void *buffer_data, sp<NativeHandle> native_handle) = 0;

	virtual status_t freeBuffer(
	OMX_U32 port_index, buffer_id buffer) = 0;

	// 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(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(
	buffer_id buffer,
	OMX_U32 range_offset, OMX_U32 range_length,
	OMX_U32 flags, OMX_TICKS timestamp, int fenceFd = -1) = 0;

	// Calls OMX_EmptyBuffer on buffer (after updating buffer header with metadata of
	// \|graphicBuffer\|, \|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. If \|origTimestamp\| >= 0,
	// timestamp on the filled buffer corresponding to this frame will be modified to
	// \|origTimestamp\| after it's filled.
	virtual status_t emptyGraphicBuffer(
	buffer_id buffer,
	const sp<GraphicBuffer> &graphicBuffer, OMX_U32 flags,
	OMX_TICKS timestamp, OMX_TICKS origTimestamp, int fenceFd) = 0;

	virtual status_t getExtensionIndex(
	const char *parameter_name,
	OMX_INDEXTYPE *index) = 0;

	virtual status_t dispatchMessage(const omx_message &msg) = 0;

	// TODO: this is temporary, will be removed when quirks move to OMX side
	virtual status_t setQuirks(OMX_U32 quirks) = 0;
	};

	struct omx_message {
	enum {
	EVENT,
	EMPTY_BUFFER_DONE,
	FILL_BUFFER_DONE,
	FRAME_RENDERED,
	} type;

	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;
	OMX_U32 data3;
	OMX_U32 data4;
	} 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);
	};

	class BnOMXNode : public BnInterface<IOMXNode> {
	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() const {
	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_