Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

am d96f6e85: Merge change I8176f35e into eclair-mr2

Browse Source 
Merge commit 'd96f6e85931e3d4ac4a6dacbedc561e56c293b8d' into eclair-mr2-plus-aosp

* commit 'd96f6e85931e3d4ac4a6dacbedc561e56c293b8d':
  Reimplement the OMX backend for stagefright.
This commit is contained in:
Andreas Huber
2009-10-16 12:51:42 -07:00
committed by Android Git Automerger
parent d27d445af8 d96f6e8593
commit 4b9dbdfa18
15 changed files with 802 additions and 484 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
cmds/stagefright/stagefright.cpp
View File

@@ -273,7 +273,7 @@ int main(int argc, char **argv) {
CHECK(service.get() != NULL); CHECK(service.get() != NULL);
sp<IOMX> omx = service->createOMX(); sp<IOMX> omx = service->getOMX();
CHECK(omx.get() != NULL); CHECK(omx.get() != NULL);
const char *kMimeTypes[] = { const char *kMimeTypes[] = {
@@ -319,11 +319,11 @@ int main(int argc, char **argv) {
CHECK(service.get() != NULL); CHECK(service.get() != NULL);
sp<IOMX> omx = service->createOMX(); sp<IOMX> omx = service->getOMX();
CHECK(omx.get() != NULL); CHECK(omx.get() != NULL);
List<String8> list; List<String8> list;
omx->list_nodes(&list); omx->listNodes(&list);
for (List<String8>::iterator it = list.begin(); for (List<String8>::iterator it = list.begin();
it != list.end(); ++it) { it != list.end(); ++it) {

2
include/media/IMediaPlayerService.h
View File

@@ -42,7 +42,7 @@ public:
virtual sp<IMediaPlayer> create(pid_t pid, const sp<IMediaPlayerClient>& client, int fd, int64_t offset, int64_t length) = 0; virtual sp<IMediaPlayer> create(pid_t pid, const sp<IMediaPlayerClient>& client, int fd, int64_t offset, int64_t length) = 0;
virtual sp<IMemory> decode(const char* url, uint32_t *pSampleRate, int* pNumChannels, int* pFormat) = 0; virtual sp<IMemory> decode(const char* url, uint32_t *pSampleRate, int* pNumChannels, int* pFormat) = 0;
virtual sp<IMemory> decode(int fd, int64_t offset, int64_t length, uint32_t *pSampleRate, int* pNumChannels, int* pFormat) = 0; virtual sp<IMemory> decode(int fd, int64_t offset, int64_t length, uint32_t *pSampleRate, int* pNumChannels, int* pFormat) = 0;
virtual sp<IOMX> createOMX() = 0; virtual sp<IOMX> getOMX() = 0;
// Take a peek at currently playing audio, for visualization purposes. // Take a peek at currently playing audio, for visualization purposes.
// This returns a buffer of 16 bit mono PCM data, or NULL if no visualization buffer is currently available. // This returns a buffer of 16 bit mono PCM data, or NULL if no visualization buffer is currently available.

38
include/media/IOMX.h
View File

@@ -42,57 +42,57 @@ public:
typedef void *buffer_id; typedef void *buffer_id;
typedef void *node_id; typedef void *node_id;
virtual status_t list_nodes(List<String8> *list) = 0; virtual status_t listNodes(List<String8> *list) = 0;
virtual status_t allocate_node(const char *name, node_id *node) = 0; virtual status_t allocateNode(
virtual status_t free_node(node_id node) = 0; const char *name, const sp<IOMXObserver> &observer,
node_id *node) = 0;
virtual status_t send_command( virtual status_t freeNode(node_id node) = 0;
virtual status_t sendCommand(
node_id node, OMX_COMMANDTYPE cmd, OMX_S32 param) = 0; node_id node, OMX_COMMANDTYPE cmd, OMX_S32 param) = 0;
virtual status_t get_parameter( virtual status_t getParameter(
node_id node, OMX_INDEXTYPE index, node_id node, OMX_INDEXTYPE index,
void *params, size_t size) = 0; void *params, size_t size) = 0;
virtual status_t set_parameter( virtual status_t setParameter(
node_id node, OMX_INDEXTYPE index, node_id node, OMX_INDEXTYPE index,
const void *params, size_t size) = 0; const void *params, size_t size) = 0;
virtual status_t get_config( virtual status_t getConfig(
node_id node, OMX_INDEXTYPE index, node_id node, OMX_INDEXTYPE index,
void *params, size_t size) = 0; void *params, size_t size) = 0;
virtual status_t set_config( virtual status_t setConfig(
node_id node, OMX_INDEXTYPE index, node_id node, OMX_INDEXTYPE index,
const void *params, size_t size) = 0; const void *params, size_t size) = 0;
virtual status_t use_buffer( virtual status_t useBuffer(
node_id node, OMX_U32 port_index, const sp<IMemory> &params, node_id node, OMX_U32 port_index, const sp<IMemory> &params,
buffer_id *buffer) = 0; buffer_id *buffer) = 0;
virtual status_t allocate_buffer( virtual status_t allocateBuffer(
node_id node, OMX_U32 port_index, size_t size, node_id node, OMX_U32 port_index, size_t size,
buffer_id *buffer) = 0; buffer_id *buffer) = 0;
virtual status_t allocate_buffer_with_backup( virtual status_t allocateBufferWithBackup(
node_id node, OMX_U32 port_index, const sp<IMemory> &params, node_id node, OMX_U32 port_index, const sp<IMemory> &params,
buffer_id *buffer) = 0; buffer_id *buffer) = 0;
virtual status_t free_buffer( virtual status_t freeBuffer(
node_id node, OMX_U32 port_index, buffer_id buffer) = 0; node_id node, OMX_U32 port_index, buffer_id buffer) = 0;
virtual status_t observe_node( virtual status_t fillBuffer(node_id node, buffer_id buffer) = 0;
node_id node, const sp<IOMXObserver> &observer) = 0;
virtual status_t fill_buffer(node_id node, buffer_id buffer) = 0; virtual status_t emptyBuffer(
virtual status_t empty_buffer(
node_id node, node_id node,
buffer_id buffer, buffer_id buffer,
OMX_U32 range_offset, OMX_U32 range_length, OMX_U32 range_offset, OMX_U32 range_length,
OMX_U32 flags, OMX_TICKS timestamp) = 0; OMX_U32 flags, OMX_TICKS timestamp) = 0;
virtual status_t get_extension_index( virtual status_t getExtensionIndex(
node_id node, node_id node,
const char *parameter_name, const char *parameter_name,
OMX_INDEXTYPE *index) = 0; OMX_INDEXTYPE *index) = 0;
@@ -162,7 +162,7 @@ class IOMXObserver : public IInterface {
public: public:
DECLARE_META_INTERFACE(OMXObserver); DECLARE_META_INTERFACE(OMXObserver);
virtual void on_message(const omx_message &msg) = 0; virtual void onMessage(const omx_message &msg) = 0;
}; };
class IOMXRenderer : public IInterface { class IOMXRenderer : public IInterface {

10
media/libmedia/IMediaPlayerService.cpp
View File

@@ -35,7 +35,7 @@ enum {
DECODE_FD, DECODE_FD,
CREATE_MEDIA_RECORDER, CREATE_MEDIA_RECORDER,
CREATE_METADATA_RETRIEVER, CREATE_METADATA_RETRIEVER,
CREATE_OMX, GET_OMX,
SNOOP SNOOP
}; };
@@ -123,10 +123,10 @@ public:
return interface_cast<IMemory>(reply.readStrongBinder()); return interface_cast<IMemory>(reply.readStrongBinder());
} }
virtual sp<IOMX> createOMX() { virtual sp<IOMX> getOMX() {
Parcel data, reply; Parcel data, reply;
data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor()); data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
remote()->transact(CREATE_OMX, data, &reply); remote()->transact(GET_OMX, data, &reply);
return interface_cast<IOMX>(reply.readStrongBinder()); return interface_cast<IOMX>(reply.readStrongBinder());
} }
}; };
@@ -207,9 +207,9 @@ status_t BnMediaPlayerService::onTransact(
reply->writeStrongBinder(retriever->asBinder()); reply->writeStrongBinder(retriever->asBinder());
return NO_ERROR; return NO_ERROR;
} break; } break;
case CREATE_OMX: { case GET_OMX: {
CHECK_INTERFACE(IMediaPlayerService, data, reply); CHECK_INTERFACE(IMediaPlayerService, data, reply);
sp<IOMX> omx = createOMX(); sp<IOMX> omx = getOMX();
reply->writeStrongBinder(omx->asBinder()); reply->writeStrongBinder(omx->asBinder());
return NO_ERROR; return NO_ERROR;
} break; } break;

96
media/libmedia/IOMX.cpp
View File

@@ -24,7 +24,6 @@ enum {
ALLOC_BUFFER, ALLOC_BUFFER,
ALLOC_BUFFER_WITH_BACKUP, ALLOC_BUFFER_WITH_BACKUP,
FREE_BUFFER, FREE_BUFFER,
OBSERVE_NODE,
FILL_BUFFER, FILL_BUFFER,
EMPTY_BUFFER, EMPTY_BUFFER,
GET_EXTENSION_INDEX, GET_EXTENSION_INDEX,
@@ -76,7 +75,7 @@ public:
: BpInterface<IOMX>(impl) { : BpInterface<IOMX>(impl) {
} }
virtual status_t list_nodes(List<String8> *list) { virtual status_t listNodes(List<String8> *list) {
list->clear(); list->clear();
Parcel data, reply; Parcel data, reply;
@@ -93,10 +92,12 @@ public:
return OK; return OK;
} }
virtual status_t allocate_node(const char *name, node_id *node) { virtual status_t allocateNode(
const char *name, const sp<IOMXObserver> &observer, node_id *node) {
Parcel data, reply; Parcel data, reply;
data.writeInterfaceToken(IOMX::getInterfaceDescriptor()); data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
data.writeCString(name); data.writeCString(name);
data.writeStrongBinder(observer->asBinder());
remote()->transact(ALLOCATE_NODE, data, &reply); remote()->transact(ALLOCATE_NODE, data, &reply);
status_t err = reply.readInt32(); status_t err = reply.readInt32();
@@ -109,7 +110,7 @@ public:
return err; return err;
} }
virtual status_t free_node(node_id node) { virtual status_t freeNode(node_id node) {
Parcel data, reply; Parcel data, reply;
data.writeInterfaceToken(IOMX::getInterfaceDescriptor()); data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
data.writeIntPtr((intptr_t)node); data.writeIntPtr((intptr_t)node);
@@ -118,7 +119,7 @@ public:
return reply.readInt32(); return reply.readInt32();
} }
virtual status_t send_command( virtual status_t sendCommand(
node_id node, OMX_COMMANDTYPE cmd, OMX_S32 param) { node_id node, OMX_COMMANDTYPE cmd, OMX_S32 param) {
Parcel data, reply; Parcel data, reply;
data.writeInterfaceToken(IOMX::getInterfaceDescriptor()); data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
@@ -130,7 +131,7 @@ public:
return reply.readInt32(); return reply.readInt32();
} }
virtual status_t get_parameter( virtual status_t getParameter(
node_id node, OMX_INDEXTYPE index, node_id node, OMX_INDEXTYPE index,
void *params, size_t size) { void *params, size_t size) {
Parcel data, reply; Parcel data, reply;
@@ -151,7 +152,7 @@ public:
return OK; return OK;
} }
virtual status_t set_parameter( virtual status_t setParameter(
node_id node, OMX_INDEXTYPE index, node_id node, OMX_INDEXTYPE index,
const void *params, size_t size) { const void *params, size_t size) {
Parcel data, reply; Parcel data, reply;
@@ -165,7 +166,7 @@ public:
return reply.readInt32(); return reply.readInt32();
} }
virtual status_t get_config( virtual status_t getConfig(
node_id node, OMX_INDEXTYPE index, node_id node, OMX_INDEXTYPE index,
void *params, size_t size) { void *params, size_t size) {
Parcel data, reply; Parcel data, reply;
@@ -186,7 +187,7 @@ public:
return OK; return OK;
} }
virtual status_t set_config( virtual status_t setConfig(
node_id node, OMX_INDEXTYPE index, node_id node, OMX_INDEXTYPE index,
const void *params, size_t size) { const void *params, size_t size) {
Parcel data, reply; Parcel data, reply;
@@ -200,7 +201,7 @@ public:
return reply.readInt32(); return reply.readInt32();
} }
virtual status_t use_buffer( virtual status_t useBuffer(
node_id node, OMX_U32 port_index, const sp<IMemory> &params, node_id node, OMX_U32 port_index, const sp<IMemory> &params,
buffer_id *buffer) { buffer_id *buffer) {
Parcel data, reply; Parcel data, reply;
@@ -222,7 +223,7 @@ public:
return err; return err;
} }
virtual status_t allocate_buffer( virtual status_t allocateBuffer(
node_id node, OMX_U32 port_index, size_t size, node_id node, OMX_U32 port_index, size_t size,
buffer_id *buffer) { buffer_id *buffer) {
Parcel data, reply; Parcel data, reply;
@@ -244,7 +245,7 @@ public:
return err; return err;
} }
virtual status_t allocate_buffer_with_backup( virtual status_t allocateBufferWithBackup(
node_id node, OMX_U32 port_index, const sp<IMemory> &params, node_id node, OMX_U32 port_index, const sp<IMemory> &params,
buffer_id *buffer) { buffer_id *buffer) {
Parcel data, reply; Parcel data, reply;
@@ -266,7 +267,7 @@ public:
return err; return err;
} }
virtual status_t free_buffer( virtual status_t freeBuffer(
node_id node, OMX_U32 port_index, buffer_id buffer) { node_id node, OMX_U32 port_index, buffer_id buffer) {
Parcel data, reply; Parcel data, reply;
data.writeInterfaceToken(IOMX::getInterfaceDescriptor()); data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
@@ -278,18 +279,7 @@ public:
return reply.readInt32(); return reply.readInt32();
} }
virtual status_t observe_node( virtual status_t fillBuffer(node_id node, buffer_id buffer) {
node_id node, const sp<IOMXObserver> &observer) {
Parcel data, reply;
data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
data.writeIntPtr((intptr_t)node);
data.writeStrongBinder(observer->asBinder());
remote()->transact(OBSERVE_NODE, data, &reply);
return reply.readInt32();
}
virtual status_t fill_buffer(node_id node, buffer_id buffer) {
Parcel data, reply; Parcel data, reply;
data.writeInterfaceToken(IOMX::getInterfaceDescriptor()); data.writeInterfaceToken(IOMX::getInterfaceDescriptor());
data.writeIntPtr((intptr_t)node); data.writeIntPtr((intptr_t)node);
@@ -299,7 +289,7 @@ public:
return reply.readInt32(); return reply.readInt32();
} }
virtual status_t empty_buffer( virtual status_t emptyBuffer(
node_id node, node_id node,
buffer_id buffer, buffer_id buffer,
OMX_U32 range_offset, OMX_U32 range_length, OMX_U32 range_offset, OMX_U32 range_length,
@@ -317,7 +307,7 @@ public:
return reply.readInt32(); return reply.readInt32();
} }
virtual status_t get_extension_index( virtual status_t getExtensionIndex(
node_id node, node_id node,
const char *parameter_name, const char *parameter_name,
OMX_INDEXTYPE *index) { OMX_INDEXTYPE *index) {
@@ -379,7 +369,7 @@ status_t BnOMX::onTransact(
CHECK_INTERFACE(IOMX, data, reply); CHECK_INTERFACE(IOMX, data, reply);
List<String8> list; List<String8> list;
list_nodes(&list); listNodes(&list);
reply->writeInt32(list.size()); reply->writeInt32(list.size());
for (List<String8>::iterator it = list.begin(); for (List<String8>::iterator it = list.begin();
@@ -394,8 +384,14 @@ status_t BnOMX::onTransact(
{ {
CHECK_INTERFACE(IOMX, data, reply); CHECK_INTERFACE(IOMX, data, reply);
const char *name = data.readCString();
sp<IOMXObserver> observer =
interface_cast<IOMXObserver>(data.readStrongBinder());
node_id node; node_id node;
status_t err = allocate_node(data.readCString(), &node);
status_t err = allocateNode(name, observer, &node);
reply->writeInt32(err); reply->writeInt32(err);
if (err == OK) { if (err == OK) {
reply->writeIntPtr((intptr_t)node); reply->writeIntPtr((intptr_t)node);
@@ -410,7 +406,7 @@ status_t BnOMX::onTransact(
node_id node = (void*)data.readIntPtr(); node_id node = (void*)data.readIntPtr();
reply->writeInt32(free_node(node)); reply->writeInt32(freeNode(node));
return NO_ERROR; return NO_ERROR;
} }
@@ -425,7 +421,7 @@ status_t BnOMX::onTransact(
static_cast<OMX_COMMANDTYPE>(data.readInt32()); static_cast<OMX_COMMANDTYPE>(data.readInt32());
OMX_S32 param = data.readInt32(); OMX_S32 param = data.readInt32();
reply->writeInt32(send_command(node, cmd, param)); reply->writeInt32(sendCommand(node, cmd, param));
return NO_ERROR; return NO_ERROR;
} }
@@ -443,7 +439,7 @@ status_t BnOMX::onTransact(
void *params = malloc(size); void *params = malloc(size);
data.read(params, size); data.read(params, size);
status_t err = get_parameter(node, index, params, size); status_t err = getParameter(node, index, params, size);
reply->writeInt32(err); reply->writeInt32(err);
@@ -467,7 +463,7 @@ status_t BnOMX::onTransact(
size_t size = data.readInt32(); size_t size = data.readInt32();
void *params = const_cast<void *>(data.readInplace(size)); void *params = const_cast<void *>(data.readInplace(size));
reply->writeInt32(set_parameter(node, index, params, size)); reply->writeInt32(setParameter(node, index, params, size));
return NO_ERROR; return NO_ERROR;
} }
@@ -485,7 +481,7 @@ status_t BnOMX::onTransact(
void *params = malloc(size); void *params = malloc(size);
data.read(params, size); data.read(params, size);
status_t err = get_config(node, index, params, size); status_t err = getConfig(node, index, params, size);
reply->writeInt32(err); reply->writeInt32(err);
@@ -509,7 +505,7 @@ status_t BnOMX::onTransact(
size_t size = data.readInt32(); size_t size = data.readInt32();
void *params = const_cast<void *>(data.readInplace(size)); void *params = const_cast<void *>(data.readInplace(size));
reply->writeInt32(set_config(node, index, params, size)); reply->writeInt32(setConfig(node, index, params, size));
return NO_ERROR; return NO_ERROR;
} }
@@ -524,7 +520,7 @@ status_t BnOMX::onTransact(
interface_cast<IMemory>(data.readStrongBinder()); interface_cast<IMemory>(data.readStrongBinder());
buffer_id buffer; buffer_id buffer;
status_t err = use_buffer(node, port_index, params, &buffer); status_t err = useBuffer(node, port_index, params, &buffer);
reply->writeInt32(err); reply->writeInt32(err);
if (err == OK) { if (err == OK) {
@@ -543,7 +539,7 @@ status_t BnOMX::onTransact(
size_t size = data.readInt32(); size_t size = data.readInt32();
buffer_id buffer; buffer_id buffer;
status_t err = allocate_buffer(node, port_index, size, &buffer); status_t err = allocateBuffer(node, port_index, size, &buffer);
reply->writeInt32(err); reply->writeInt32(err);
if (err == OK) { if (err == OK) {
@@ -563,7 +559,7 @@ status_t BnOMX::onTransact(
interface_cast<IMemory>(data.readStrongBinder()); interface_cast<IMemory>(data.readStrongBinder());
buffer_id buffer; buffer_id buffer;
status_t err = allocate_buffer_with_backup( status_t err = allocateBufferWithBackup(
node, port_index, params, &buffer); node, port_index, params, &buffer);
reply->writeInt32(err); reply->writeInt32(err);
@@ -582,19 +578,7 @@ status_t BnOMX::onTransact(
node_id node = (void*)data.readIntPtr(); node_id node = (void*)data.readIntPtr();
OMX_U32 port_index = data.readInt32(); OMX_U32 port_index = data.readInt32();
buffer_id buffer = (void*)data.readIntPtr(); buffer_id buffer = (void*)data.readIntPtr();
reply->writeInt32(free_buffer(node, port_index, buffer)); reply->writeInt32(freeBuffer(node, port_index, buffer));
return NO_ERROR;
}
case OBSERVE_NODE:
{
CHECK_INTERFACE(IOMX, data, reply);
node_id node = (void*)data.readIntPtr();
sp<IOMXObserver> observer =
interface_cast<IOMXObserver>(data.readStrongBinder());
reply->writeInt32(observe_node(node, observer));
return NO_ERROR; return NO_ERROR;
} }
@@ -605,7 +589,7 @@ status_t BnOMX::onTransact(
node_id node = (void*)data.readIntPtr(); node_id node = (void*)data.readIntPtr();
buffer_id buffer = (void*)data.readIntPtr(); buffer_id buffer = (void*)data.readIntPtr();
reply->writeInt32(fill_buffer(node, buffer)); reply->writeInt32(fillBuffer(node, buffer));
return NO_ERROR; return NO_ERROR;
} }
@@ -622,7 +606,7 @@ status_t BnOMX::onTransact(
OMX_TICKS timestamp = data.readInt64(); OMX_TICKS timestamp = data.readInt64();
reply->writeInt32( reply->writeInt32(
empty_buffer( emptyBuffer(
node, buffer, range_offset, range_length, node, buffer, range_offset, range_length,
flags, timestamp)); flags, timestamp));
@@ -637,7 +621,7 @@ status_t BnOMX::onTransact(
const char *parameter_name = data.readCString(); const char *parameter_name = data.readCString();
OMX_INDEXTYPE index; OMX_INDEXTYPE index;
status_t err = get_extension_index(node, parameter_name, &index); status_t err = getExtensionIndex(node, parameter_name, &index);
reply->writeInt32(err); reply->writeInt32(err);
@@ -688,7 +672,7 @@ public:
: BpInterface<IOMXObserver>(impl) { : BpInterface<IOMXObserver>(impl) {
} }
virtual void on_message(const omx_message &msg) { virtual void onMessage(const omx_message &msg) {
Parcel data, reply; Parcel data, reply;
data.writeInterfaceToken(IOMXObserver::getInterfaceDescriptor()); data.writeInterfaceToken(IOMXObserver::getInterfaceDescriptor());
data.write(&msg, sizeof(msg)); data.write(&msg, sizeof(msg));
@@ -710,7 +694,7 @@ status_t BnOMXObserver::onTransact(
data.read(&msg, sizeof(msg)); data.read(&msg, sizeof(msg));
// XXX Could use readInplace maybe? // XXX Could use readInplace maybe?
on_message(msg); onMessage(msg);
return NO_ERROR; return NO_ERROR;
} }

2
media/libmediaplayerservice/Android.mk
View File

@@ -51,7 +51,7 @@ LOCAL_C_INCLUDES := external/tremor/Tremor \
$(JNI_H_INCLUDE) \ $(JNI_H_INCLUDE) \
$(call include-path-for, graphics corecg) \ $(call include-path-for, graphics corecg) \
$(TOP)/external/opencore/extern_libs_v2/khronos/openmax/include \ $(TOP)/external/opencore/extern_libs_v2/khronos/openmax/include \
$(TOP)/frameworks/base/media/libstagefright/omx $(TOP)/frameworks/base/media/libstagefright/include
LOCAL_MODULE:= libmediaplayerservice LOCAL_MODULE:= libmediaplayerservice

10
media/libmediaplayerservice/MediaPlayerService.cpp
View File

@@ -274,8 +274,14 @@ sp<IMediaPlayer> MediaPlayerService::create(pid_t pid, const sp<IMediaPlayerClie
return c; return c;
} }
sp<IOMX> MediaPlayerService::createOMX() { sp<IOMX> MediaPlayerService::getOMX() {
return new OMX; Mutex::Autolock autoLock(mLock);
if (mOMX.get() == NULL) {
mOMX = new OMX;
}
return mOMX;
} }
status_t MediaPlayerService::AudioCache::dump(int fd, const Vector<String16>& args) const status_t MediaPlayerService::AudioCache::dump(int fd, const Vector<String16>& args) const

3
media/libmediaplayerservice/MediaPlayerService.h
View File

@@ -183,7 +183,7 @@ public:
virtual sp<IMemory> decode(const char* url, uint32_t *pSampleRate, int* pNumChannels, int* pFormat); virtual sp<IMemory> decode(const char* url, uint32_t *pSampleRate, int* pNumChannels, int* pFormat);
virtual sp<IMemory> decode(int fd, int64_t offset, int64_t length, uint32_t *pSampleRate, int* pNumChannels, int* pFormat); virtual sp<IMemory> decode(int fd, int64_t offset, int64_t length, uint32_t *pSampleRate, int* pNumChannels, int* pFormat);
virtual sp<IMemory> snoop(); virtual sp<IMemory> snoop();
virtual sp<IOMX> createOMX(); virtual sp<IOMX> getOMX();
virtual status_t dump(int fd, const Vector<String16>& args); virtual status_t dump(int fd, const Vector<String16>& args);
@@ -281,6 +281,7 @@ private:
mutable Mutex mLock; mutable Mutex mLock;
SortedVector< wp<Client> > mClients; SortedVector< wp<Client> > mClients;
int32_t mNextConnId; int32_t mNextConnId;
sp<IOMX> mOMX;
}; };
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------

2
media/libstagefright/OMXClient.cpp
View File

@@ -35,7 +35,7 @@ status_t OMXClient::connect() {
CHECK(service.get() != NULL); CHECK(service.get() != NULL);
mOMX = service->createOMX(); mOMX = service->getOMX();
CHECK(mOMX.get() != NULL); CHECK(mOMX.get() != NULL);
return OK; return OK;

143
media/libstagefright/OMXCodec.cpp
View File

@@ -88,12 +88,15 @@ static const CodecInfo kEncoderInfo[] = {
#define CODEC_LOGV(x, ...) LOGV("[%s] "x, mComponentName, ##__VA_ARGS__) #define CODEC_LOGV(x, ...) LOGV("[%s] "x, mComponentName, ##__VA_ARGS__)
struct OMXCodecObserver : public BnOMXObserver { struct OMXCodecObserver : public BnOMXObserver {
OMXCodecObserver(const wp<OMXCodec> &target) OMXCodecObserver() {
: mTarget(target) { }
void setCodec(const sp<OMXCodec> &target) {
mTarget = target;
} }
// from IOMXObserver // from IOMXObserver
virtual void on_message(const omx_message &msg) { virtual void onMessage(const omx_message &msg) {
sp<OMXCodec> codec = mTarget.promote(); sp<OMXCodec> codec = mTarget.promote();
if (codec.get() != NULL) { if (codec.get() != NULL) {
@@ -180,6 +183,7 @@ sp<OMXCodec> OMXCodec::Create(
CHECK(success); CHECK(success);
const char *componentName = NULL; const char *componentName = NULL;
sp<OMXCodecObserver> observer = new OMXCodecObserver;
IOMX::node_id node = 0; IOMX::node_id node = 0;
for (int index = 0;; ++index) { for (int index = 0;; ++index) {
if (createEncoder) { if (createEncoder) {
@@ -203,7 +207,7 @@ sp<OMXCodec> OMXCodec::Create(
LOGV("Attempting to allocate OMX node '%s'", componentName); LOGV("Attempting to allocate OMX node '%s'", componentName);
status_t err = omx->allocate_node(componentName, &node); status_t err = omx->allocateNode(componentName, observer, &node);
if (err == OK) { if (err == OK) {
LOGV("Successfully allocated OMX node '%s'", componentName); LOGV("Successfully allocated OMX node '%s'", componentName);
break; break;
@@ -245,6 +249,8 @@ sp<OMXCodec> OMXCodec::Create(
omx, node, quirks, createEncoder, mime, componentName, omx, node, quirks, createEncoder, mime, componentName,
source); source);
observer->setCodec(codec);
uint32_t type; uint32_t type;
const void *data; const void *data;
size_t size; size_t size;
@@ -325,15 +331,15 @@ sp<OMXCodec> OMXCodec::Create(
LOGV("AVC profile = %d (%s), level = %d", LOGV("AVC profile = %d (%s), level = %d",
(int)profile, AVCProfileToString(profile), (int)level / 10); (int)profile, AVCProfileToString(profile), (int)level / 10);
#if 0
if (!strcmp(componentName, "OMX.TI.Video.Decoder") if (!strcmp(componentName, "OMX.TI.Video.Decoder")
&& (profile != kAVCProfileBaseline || level > 39)) { && (profile != kAVCProfileBaseline || level > 39)) {
// This stream exceeds the decoder's capabilities. // This stream exceeds the decoder's capabilities. The decoder
// does not handle this gracefully and would clobber the heap
// and wreak havoc instead...
LOGE("Profile and/or level exceed the decoder's capabilities."); LOGE("Profile and/or level exceed the decoder's capabilities.");
return NULL; return NULL;
} }
#endif
} }
if (!strcasecmp(MEDIA_MIMETYPE_AUDIO_AMR_NB, mime)) { if (!strcasecmp(MEDIA_MIMETYPE_AUDIO_AMR_NB, mime)) {
@@ -404,7 +410,7 @@ void OMXCodec::setMinBufferSize(OMX_U32 portIndex, OMX_U32 size) {
InitOMXParams(&def); InitOMXParams(&def);
def.nPortIndex = portIndex; def.nPortIndex = portIndex;
status_t err = mOMX->get_parameter( status_t err = mOMX->getParameter(
mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -413,7 +419,7 @@ void OMXCodec::setMinBufferSize(OMX_U32 portIndex, OMX_U32 size) {
} }
err = mOMX->set_parameter( err = mOMX->setParameter(
mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
} }
@@ -431,7 +437,7 @@ status_t OMXCodec::setVideoPortFormatType(
OMX_U32 index = 0; OMX_U32 index = 0;
for (;;) { for (;;) {
format.nIndex = index; format.nIndex = index;
status_t err = mOMX->get_parameter( status_t err = mOMX->getParameter(
mNode, OMX_IndexParamVideoPortFormat, mNode, OMX_IndexParamVideoPortFormat,
&format, sizeof(format)); &format, sizeof(format));
@@ -477,7 +483,7 @@ status_t OMXCodec::setVideoPortFormatType(
} }
CODEC_LOGV("found a match."); CODEC_LOGV("found a match.");
status_t err = mOMX->set_parameter( status_t err = mOMX->setParameter(
mNode, OMX_IndexParamVideoPortFormat, mNode, OMX_IndexParamVideoPortFormat,
&format, sizeof(format)); &format, sizeof(format));
@@ -520,7 +526,7 @@ void OMXCodec::setVideoInputFormat(
OMX_VIDEO_PORTDEFINITIONTYPE *video_def = &def.format.video; OMX_VIDEO_PORTDEFINITIONTYPE *video_def = &def.format.video;
status_t err = mOMX->get_parameter( status_t err = mOMX->getParameter(
mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -532,7 +538,7 @@ void OMXCodec::setVideoInputFormat(
video_def->eCompressionFormat = compressionFormat; video_def->eCompressionFormat = compressionFormat;
video_def->eColorFormat = OMX_COLOR_FormatUnused; video_def->eColorFormat = OMX_COLOR_FormatUnused;
err = mOMX->set_parameter( err = mOMX->setParameter(
mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -541,7 +547,7 @@ void OMXCodec::setVideoInputFormat(
InitOMXParams(&def); InitOMXParams(&def);
def.nPortIndex = kPortIndexInput; def.nPortIndex = kPortIndexInput;
err = mOMX->get_parameter( err = mOMX->getParameter(
mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -555,7 +561,7 @@ void OMXCodec::setVideoInputFormat(
video_def->eCompressionFormat = OMX_VIDEO_CodingUnused; video_def->eCompressionFormat = OMX_VIDEO_CodingUnused;
video_def->eColorFormat = colorFormat; video_def->eColorFormat = colorFormat;
err = mOMX->set_parameter( err = mOMX->setParameter(
mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
} }
@@ -586,7 +592,7 @@ void OMXCodec::setVideoOutputFormat(
format.nPortIndex = kPortIndexOutput; format.nPortIndex = kPortIndexOutput;
format.nIndex = 0; format.nIndex = 0;
status_t err = mOMX->get_parameter( status_t err = mOMX->getParameter(
mNode, OMX_IndexParamVideoPortFormat, mNode, OMX_IndexParamVideoPortFormat,
&format, sizeof(format)); &format, sizeof(format));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -599,7 +605,7 @@ void OMXCodec::setVideoOutputFormat(
|| format.eColorFormat == OMX_COLOR_FormatCbYCrY || format.eColorFormat == OMX_COLOR_FormatCbYCrY
|| format.eColorFormat == OMX_QCOM_COLOR_FormatYVU420SemiPlanar); || format.eColorFormat == OMX_QCOM_COLOR_FormatYVU420SemiPlanar);
err = mOMX->set_parameter( err = mOMX->setParameter(
mNode, OMX_IndexParamVideoPortFormat, mNode, OMX_IndexParamVideoPortFormat,
&format, sizeof(format)); &format, sizeof(format));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -612,7 +618,7 @@ void OMXCodec::setVideoOutputFormat(
OMX_VIDEO_PORTDEFINITIONTYPE *video_def = &def.format.video; OMX_VIDEO_PORTDEFINITIONTYPE *video_def = &def.format.video;
status_t err = mOMX->get_parameter( status_t err = mOMX->getParameter(
mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -632,7 +638,7 @@ void OMXCodec::setVideoOutputFormat(
video_def->eColorFormat = OMX_COLOR_FormatUnused; video_def->eColorFormat = OMX_COLOR_FormatUnused;
err = mOMX->set_parameter( err = mOMX->setParameter(
mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -641,7 +647,7 @@ void OMXCodec::setVideoOutputFormat(
InitOMXParams(&def); InitOMXParams(&def);
def.nPortIndex = kPortIndexOutput; def.nPortIndex = kPortIndexOutput;
err = mOMX->get_parameter( err = mOMX->getParameter(
mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
CHECK_EQ(def.eDomain, OMX_PortDomainVideo); CHECK_EQ(def.eDomain, OMX_PortDomainVideo);
@@ -654,7 +660,7 @@ void OMXCodec::setVideoOutputFormat(
video_def->nFrameWidth = width; video_def->nFrameWidth = width;
video_def->nFrameHeight = height; video_def->nFrameHeight = height;
err = mOMX->set_parameter( err = mOMX->setParameter(
mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
} }
@@ -683,9 +689,6 @@ OMXCodec::OMXCodec(
mPortStatus[kPortIndexInput] = ENABLED; mPortStatus[kPortIndexInput] = ENABLED;
mPortStatus[kPortIndexOutput] = ENABLED; mPortStatus[kPortIndexOutput] = ENABLED;
mObserver = new OMXCodecObserver(this);
mOMX->observe_node(mNode, mObserver);
setComponentRole(); setComponentRole();
} }
@@ -743,7 +746,7 @@ void OMXCodec::setComponentRole(
roleParams.cRole[OMX_MAX_STRINGNAME_SIZE - 1] = '\0'; roleParams.cRole[OMX_MAX_STRINGNAME_SIZE - 1] = '\0';
status_t err = omx->set_parameter( status_t err = omx->setParameter(
node, OMX_IndexParamStandardComponentRole, node, OMX_IndexParamStandardComponentRole,
&roleParams, sizeof(roleParams)); &roleParams, sizeof(roleParams));
@@ -760,10 +763,7 @@ void OMXCodec::setComponentRole() {
OMXCodec::~OMXCodec() { OMXCodec::~OMXCodec() {
CHECK(mState == LOADED || mState == ERROR); CHECK(mState == LOADED || mState == ERROR);
status_t err = mOMX->observe_node(mNode, NULL); status_t err = mOMX->freeNode(mNode);
CHECK_EQ(err, OK);
err = mOMX->free_node(mNode);
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
mNode = NULL; mNode = NULL;
@@ -785,7 +785,7 @@ status_t OMXCodec::init() {
status_t err; status_t err;
if (!(mQuirks & kRequiresLoadedToIdleAfterAllocation)) { if (!(mQuirks & kRequiresLoadedToIdleAfterAllocation)) {
err = mOMX->send_command(mNode, OMX_CommandStateSet, OMX_StateIdle); err = mOMX->sendCommand(mNode, OMX_CommandStateSet, OMX_StateIdle);
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
setState(LOADED_TO_IDLE); setState(LOADED_TO_IDLE);
} }
@@ -794,7 +794,7 @@ status_t OMXCodec::init() {
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
if (mQuirks & kRequiresLoadedToIdleAfterAllocation) { if (mQuirks & kRequiresLoadedToIdleAfterAllocation) {
err = mOMX->send_command(mNode, OMX_CommandStateSet, OMX_StateIdle); err = mOMX->sendCommand(mNode, OMX_CommandStateSet, OMX_StateIdle);
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
setState(LOADED_TO_IDLE); setState(LOADED_TO_IDLE);
@@ -831,7 +831,7 @@ status_t OMXCodec::allocateBuffersOnPort(OMX_U32 portIndex) {
InitOMXParams(&def); InitOMXParams(&def);
def.nPortIndex = portIndex; def.nPortIndex = portIndex;
status_t err = mOMX->get_parameter( status_t err = mOMX->getParameter(
mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
if (err != OK) { if (err != OK) {
@@ -848,14 +848,14 @@ status_t OMXCodec::allocateBuffersOnPort(OMX_U32 portIndex) {
IOMX::buffer_id buffer; IOMX::buffer_id buffer;
if (portIndex == kPortIndexInput if (portIndex == kPortIndexInput
&& (mQuirks & kRequiresAllocateBufferOnInputPorts)) { && (mQuirks & kRequiresAllocateBufferOnInputPorts)) {
err = mOMX->allocate_buffer_with_backup( err = mOMX->allocateBufferWithBackup(
mNode, portIndex, mem, &buffer); mNode, portIndex, mem, &buffer);
} else if (portIndex == kPortIndexOutput } else if (portIndex == kPortIndexOutput
&& (mQuirks & kRequiresAllocateBufferOnOutputPorts)) { && (mQuirks & kRequiresAllocateBufferOnOutputPorts)) {
err = mOMX->allocate_buffer_with_backup( err = mOMX->allocateBufferWithBackup(
mNode, portIndex, mem, &buffer); mNode, portIndex, mem, &buffer);
} else { } else {
err = mOMX->use_buffer(mNode, portIndex, mem, &buffer); err = mOMX->useBuffer(mNode, portIndex, mem, &buffer);
} }
if (err != OK) { if (err != OK) {
@@ -922,7 +922,7 @@ void OMXCodec::on_message(const omx_message &msg) {
CODEC_LOGV("Port is disabled, freeing buffer %p", buffer); CODEC_LOGV("Port is disabled, freeing buffer %p", buffer);
status_t err = status_t err =
mOMX->free_buffer(mNode, kPortIndexInput, buffer); mOMX->freeBuffer(mNode, kPortIndexInput, buffer);
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
buffers->removeAt(i); buffers->removeAt(i);
@@ -968,7 +968,7 @@ void OMXCodec::on_message(const omx_message &msg) {
CODEC_LOGV("Port is disabled, freeing buffer %p", buffer); CODEC_LOGV("Port is disabled, freeing buffer %p", buffer);
status_t err = status_t err =
mOMX->free_buffer(mNode, kPortIndexOutput, buffer); mOMX->freeBuffer(mNode, kPortIndexOutput, buffer);
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
buffers->removeAt(i); buffers->removeAt(i);
@@ -1137,7 +1137,7 @@ void OMXCodec::onCmdComplete(OMX_COMMANDTYPE cmd, OMX_U32 data) {
mPortStatus[kPortIndexOutput] = SHUTTING_DOWN; mPortStatus[kPortIndexOutput] = SHUTTING_DOWN;
status_t err = status_t err =
mOMX->send_command(mNode, OMX_CommandStateSet, OMX_StateIdle); mOMX->sendCommand(mNode, OMX_CommandStateSet, OMX_StateIdle);
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
} }
} else { } else {
@@ -1177,7 +1177,7 @@ void OMXCodec::onStateChange(OMX_STATETYPE newState) {
{ {
CODEC_LOGV("Now Idle."); CODEC_LOGV("Now Idle.");
if (mState == LOADED_TO_IDLE) { if (mState == LOADED_TO_IDLE) {
status_t err = mOMX->send_command( status_t err = mOMX->sendCommand(
mNode, OMX_CommandStateSet, OMX_StateExecuting); mNode, OMX_CommandStateSet, OMX_StateExecuting);
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -1194,7 +1194,7 @@ void OMXCodec::onStateChange(OMX_STATETYPE newState) {
countBuffersWeOwn(mPortBuffers[kPortIndexOutput]), countBuffersWeOwn(mPortBuffers[kPortIndexOutput]),
mPortBuffers[kPortIndexOutput].size()); mPortBuffers[kPortIndexOutput].size());
status_t err = mOMX->send_command( status_t err = mOMX->sendCommand(
mNode, OMX_CommandStateSet, OMX_StateLoaded); mNode, OMX_CommandStateSet, OMX_StateLoaded);
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -1277,7 +1277,7 @@ status_t OMXCodec::freeBuffersOnPort(
CODEC_LOGV("freeing buffer %p on port %ld", info->mBuffer, portIndex); CODEC_LOGV("freeing buffer %p on port %ld", info->mBuffer, portIndex);
status_t err = status_t err =
mOMX->free_buffer(mNode, portIndex, info->mBuffer); mOMX->freeBuffer(mNode, portIndex, info->mBuffer);
if (err != OK) { if (err != OK) {
stickyErr = err; stickyErr = err;
@@ -1337,7 +1337,7 @@ bool OMXCodec::flushPortAsync(OMX_U32 portIndex) {
} }
status_t err = status_t err =
mOMX->send_command(mNode, OMX_CommandFlush, portIndex); mOMX->sendCommand(mNode, OMX_CommandFlush, portIndex);
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
return true; return true;
@@ -1350,7 +1350,7 @@ void OMXCodec::disablePortAsync(OMX_U32 portIndex) {
mPortStatus[portIndex] = DISABLING; mPortStatus[portIndex] = DISABLING;
status_t err = status_t err =
mOMX->send_command(mNode, OMX_CommandPortDisable, portIndex); mOMX->sendCommand(mNode, OMX_CommandPortDisable, portIndex);
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
freeBuffersOnPort(portIndex, true); freeBuffersOnPort(portIndex, true);
@@ -1363,7 +1363,7 @@ void OMXCodec::enablePortAsync(OMX_U32 portIndex) {
mPortStatus[portIndex] = ENABLING; mPortStatus[portIndex] = ENABLING;
status_t err = status_t err =
mOMX->send_command(mNode, OMX_CommandPortEnable, portIndex); mOMX->sendCommand(mNode, OMX_CommandPortEnable, portIndex);
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
} }
@@ -1415,7 +1415,7 @@ void OMXCodec::drainInputBuffer(BufferInfo *info) {
memcpy(info->mMem->pointer(), specific->mData, specific->mSize); memcpy(info->mMem->pointer(), specific->mData, specific->mSize);
} }
status_t err = mOMX->empty_buffer( status_t err = mOMX->emptyBuffer(
mNode, info->mBuffer, 0, size, mNode, info->mBuffer, 0, size,
OMX_BUFFERFLAG_ENDOFFRAME | OMX_BUFFERFLAG_CODECCONFIG, OMX_BUFFERFLAG_ENDOFFRAME | OMX_BUFFERFLAG_CODECCONFIG,
0); 0);
@@ -1461,9 +1461,9 @@ void OMXCodec::drainInputBuffer(BufferInfo *info) {
srcLength); srcLength);
if (srcBuffer->meta_data()->findInt64(kKeyTime, &timestampUs)) { if (srcBuffer->meta_data()->findInt64(kKeyTime, &timestampUs)) {
CODEC_LOGV("Calling empty_buffer on buffer %p (length %d)", CODEC_LOGV("Calling emptyBuffer on buffer %p (length %d)",
info->mBuffer, srcLength); info->mBuffer, srcLength);
CODEC_LOGV("Calling empty_buffer with timestamp %lld us (%.2f secs)", CODEC_LOGV("Calling emptyBuffer with timestamp %lld us (%.2f secs)",
timestampUs, timestampUs / 1E6); timestampUs, timestampUs / 1E6);
} }
} }
@@ -1473,7 +1473,7 @@ void OMXCodec::drainInputBuffer(BufferInfo *info) {
srcBuffer = NULL; srcBuffer = NULL;
} }
err = mOMX->empty_buffer( err = mOMX->emptyBuffer(
mNode, info->mBuffer, 0, srcLength, mNode, info->mBuffer, 0, srcLength,
flags, timestampUs); flags, timestampUs);
@@ -1495,7 +1495,7 @@ void OMXCodec::fillOutputBuffer(BufferInfo *info) {
} }
CODEC_LOGV("Calling fill_buffer on buffer %p", info->mBuffer); CODEC_LOGV("Calling fill_buffer on buffer %p", info->mBuffer);
status_t err = mOMX->fill_buffer(mNode, info->mBuffer); status_t err = mOMX->fillBuffer(mNode, info->mBuffer);
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
info->mOwnedByComponent = true; info->mOwnedByComponent = true;
@@ -1540,7 +1540,7 @@ void OMXCodec::setRawAudioFormat(
InitOMXParams(&pcmParams); InitOMXParams(&pcmParams);
pcmParams.nPortIndex = portIndex; pcmParams.nPortIndex = portIndex;
status_t err = mOMX->get_parameter( status_t err = mOMX->getParameter(
mNode, OMX_IndexParamAudioPcm, &pcmParams, sizeof(pcmParams)); mNode, OMX_IndexParamAudioPcm, &pcmParams, sizeof(pcmParams));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -1561,7 +1561,7 @@ void OMXCodec::setRawAudioFormat(
pcmParams.eChannelMapping[1] = OMX_AUDIO_ChannelRF; pcmParams.eChannelMapping[1] = OMX_AUDIO_ChannelRF;
} }
err = mOMX->set_parameter( err = mOMX->setParameter(
mNode, OMX_IndexParamAudioPcm, &pcmParams, sizeof(pcmParams)); mNode, OMX_IndexParamAudioPcm, &pcmParams, sizeof(pcmParams));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -1574,14 +1574,14 @@ void OMXCodec::setAMRFormat() {
def.nPortIndex = kPortIndexInput; def.nPortIndex = kPortIndexInput;
status_t err = status_t err =
mOMX->get_parameter(mNode, OMX_IndexParamAudioAmr, &def, sizeof(def)); mOMX->getParameter(mNode, OMX_IndexParamAudioAmr, &def, sizeof(def));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
def.eAMRFrameFormat = OMX_AUDIO_AMRFrameFormatFSF; def.eAMRFrameFormat = OMX_AUDIO_AMRFrameFormatFSF;
def.eAMRBandMode = OMX_AUDIO_AMRBandModeNB0; def.eAMRBandMode = OMX_AUDIO_AMRBandModeNB0;
err = mOMX->set_parameter(mNode, OMX_IndexParamAudioAmr, &def, sizeof(def)); err = mOMX->setParameter(mNode, OMX_IndexParamAudioAmr, &def, sizeof(def));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
} }
@@ -1605,14 +1605,14 @@ void OMXCodec::setAMRWBFormat() {
def.nPortIndex = kPortIndexInput; def.nPortIndex = kPortIndexInput;
status_t err = status_t err =
mOMX->get_parameter(mNode, OMX_IndexParamAudioAmr, &def, sizeof(def)); mOMX->getParameter(mNode, OMX_IndexParamAudioAmr, &def, sizeof(def));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
def.eAMRFrameFormat = OMX_AUDIO_AMRFrameFormatFSF; def.eAMRFrameFormat = OMX_AUDIO_AMRFrameFormatFSF;
def.eAMRBandMode = OMX_AUDIO_AMRBandModeWB0; def.eAMRBandMode = OMX_AUDIO_AMRBandModeWB0;
err = mOMX->set_parameter(mNode, OMX_IndexParamAudioAmr, &def, sizeof(def)); err = mOMX->setParameter(mNode, OMX_IndexParamAudioAmr, &def, sizeof(def));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
} }
@@ -1637,7 +1637,7 @@ void OMXCodec::setAACFormat(int32_t numChannels, int32_t sampleRate) {
InitOMXParams(&profile); InitOMXParams(&profile);
profile.nPortIndex = kPortIndexInput; profile.nPortIndex = kPortIndexInput;
status_t err = mOMX->get_parameter( status_t err = mOMX->getParameter(
mNode, OMX_IndexParamAudioAac, &profile, sizeof(profile)); mNode, OMX_IndexParamAudioAac, &profile, sizeof(profile));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -1645,7 +1645,7 @@ void OMXCodec::setAACFormat(int32_t numChannels, int32_t sampleRate) {
profile.nSampleRate = sampleRate; profile.nSampleRate = sampleRate;
profile.eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP4ADTS; profile.eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP4ADTS;
err = mOMX->set_parameter( err = mOMX->setParameter(
mNode, OMX_IndexParamAudioAac, &profile, sizeof(profile)); mNode, OMX_IndexParamAudioAac, &profile, sizeof(profile));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
} }
@@ -1669,7 +1669,7 @@ void OMXCodec::setImageOutputFormat(
InitOMXParams(&def); InitOMXParams(&def);
def.nPortIndex = kPortIndexOutput; def.nPortIndex = kPortIndexOutput;
status_t err = mOMX->get_parameter( status_t err = mOMX->getParameter(
mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -1718,7 +1718,7 @@ void OMXCodec::setImageOutputFormat(
def.nBufferCountActual = def.nBufferCountMin; def.nBufferCountActual = def.nBufferCountMin;
err = mOMX->set_parameter( err = mOMX->setParameter(
mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
} }
@@ -1729,7 +1729,7 @@ void OMXCodec::setJPEGInputFormat(
InitOMXParams(&def); InitOMXParams(&def);
def.nPortIndex = kPortIndexInput; def.nPortIndex = kPortIndexInput;
status_t err = mOMX->get_parameter( status_t err = mOMX->getParameter(
mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -1743,7 +1743,7 @@ void OMXCodec::setJPEGInputFormat(
def.nBufferSize = compressedSize; def.nBufferSize = compressedSize;
def.nBufferCountActual = def.nBufferCountMin; def.nBufferCountActual = def.nBufferCountMin;
err = mOMX->set_parameter( err = mOMX->setParameter(
mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
} }
@@ -1834,7 +1834,7 @@ status_t OMXCodec::stop() {
mPortStatus[kPortIndexOutput] = SHUTTING_DOWN; mPortStatus[kPortIndexOutput] = SHUTTING_DOWN;
status_t err = status_t err =
mOMX->send_command(mNode, OMX_CommandStateSet, OMX_StateIdle); mOMX->sendCommand(mNode, OMX_CommandStateSet, OMX_StateIdle);
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
} }
@@ -2172,7 +2172,7 @@ void OMXCodec::dumpPortStatus(OMX_U32 portIndex) {
InitOMXParams(&def); InitOMXParams(&def);
def.nPortIndex = portIndex; def.nPortIndex = portIndex;
status_t err = mOMX->get_parameter( status_t err = mOMX->getParameter(
mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -2238,7 +2238,7 @@ void OMXCodec::dumpPortStatus(OMX_U32 portIndex) {
InitOMXParams(&params); InitOMXParams(&params);
params.nPortIndex = portIndex; params.nPortIndex = portIndex;
err = mOMX->get_parameter( err = mOMX->getParameter(
mNode, OMX_IndexParamAudioPcm, &params, sizeof(params)); mNode, OMX_IndexParamAudioPcm, &params, sizeof(params));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -2257,7 +2257,7 @@ void OMXCodec::dumpPortStatus(OMX_U32 portIndex) {
InitOMXParams(&amr); InitOMXParams(&amr);
amr.nPortIndex = portIndex; amr.nPortIndex = portIndex;
err = mOMX->get_parameter( err = mOMX->getParameter(
mNode, OMX_IndexParamAudioAmr, &amr, sizeof(amr)); mNode, OMX_IndexParamAudioAmr, &amr, sizeof(amr));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -2289,7 +2289,7 @@ void OMXCodec::initOutputFormat(const sp<MetaData> &inputFormat) {
InitOMXParams(&def); InitOMXParams(&def);
def.nPortIndex = kPortIndexOutput; def.nPortIndex = kPortIndexOutput;
status_t err = mOMX->get_parameter( status_t err = mOMX->getParameter(
mNode, OMX_IndexParamPortDefinition, &def, sizeof(def)); mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -2315,7 +2315,7 @@ void OMXCodec::initOutputFormat(const sp<MetaData> &inputFormat) {
InitOMXParams(&params); InitOMXParams(&params);
params.nPortIndex = kPortIndexOutput; params.nPortIndex = kPortIndexOutput;
err = mOMX->get_parameter( err = mOMX->getParameter(
mNode, OMX_IndexParamAudioPcm, &params, sizeof(params)); mNode, OMX_IndexParamAudioPcm, &params, sizeof(params));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -2347,7 +2347,7 @@ void OMXCodec::initOutputFormat(const sp<MetaData> &inputFormat) {
InitOMXParams(&amr); InitOMXParams(&amr);
amr.nPortIndex = kPortIndexOutput; amr.nPortIndex = kPortIndexOutput;
err = mOMX->get_parameter( err = mOMX->getParameter(
mNode, OMX_IndexParamAudioAmr, &amr, sizeof(amr)); mNode, OMX_IndexParamAudioAmr, &amr, sizeof(amr));
CHECK_EQ(err, OK); CHECK_EQ(err, OK);
@@ -2444,8 +2444,9 @@ status_t QueryCodecs(
return OK; return OK;
} }
sp<OMXCodecObserver> observer = new OMXCodecObserver;
IOMX::node_id node; IOMX::node_id node;
status_t err = omx->allocate_node(componentName, &node); status_t err = omx->allocateNode(componentName, observer, &node);
if (err != OK) { if (err != OK) {
continue; continue;
@@ -2463,7 +2464,7 @@ status_t QueryCodecs(
param.nPortIndex = queryDecoders ? 0 : 1; param.nPortIndex = queryDecoders ? 0 : 1;
for (param.nProfileIndex = 0;; ++param.nProfileIndex) { for (param.nProfileIndex = 0;; ++param.nProfileIndex) {
err = omx->get_parameter( err = omx->getParameter(
node, OMX_IndexParamVideoProfileLevelQuerySupported, node, OMX_IndexParamVideoProfileLevelQuerySupported,
&param, sizeof(param)); &param, sizeof(param));
@@ -2478,7 +2479,7 @@ status_t QueryCodecs(
caps->mProfileLevels.push(profileLevel); caps->mProfileLevels.push(profileLevel);
} }
CHECK_EQ(omx->free_node(node), OK); CHECK_EQ(omx->freeNode(node), OK);
} }
} }

91
media/libstagefright/omx/OMX.h → media/libstagefright/include/OMX.h
View File

@@ -19,66 +19,67 @@
#include <media/IOMX.h> #include <media/IOMX.h>
#include <utils/threads.h> #include <utils/threads.h>
#include <utils/KeyedVector.h>
namespace android { namespace android {
class NodeMeta; class OMXNodeInstance;
class OMX : public BnOMX { class OMX : public BnOMX,
public IBinder::DeathRecipient {
public: public:
OMX(); OMX();
virtual status_t list_nodes(List<String8> *list); virtual status_t listNodes(List<String8> *list);
virtual status_t allocate_node(const char *name, node_id *node); virtual status_t allocateNode(
virtual status_t free_node(node_id node); const char *name, const sp<IOMXObserver> &observer, node_id *node);
virtual status_t send_command( virtual status_t freeNode(node_id node);
virtual status_t sendCommand(
node_id node, OMX_COMMANDTYPE cmd, OMX_S32 param); node_id node, OMX_COMMANDTYPE cmd, OMX_S32 param);
virtual status_t get_parameter( virtual status_t getParameter(
node_id node, OMX_INDEXTYPE index, node_id node, OMX_INDEXTYPE index,
void *params, size_t size); void *params, size_t size);
virtual status_t set_parameter( virtual status_t setParameter(
node_id node, OMX_INDEXTYPE index, node_id node, OMX_INDEXTYPE index,
const void *params, size_t size); const void *params, size_t size);
virtual status_t get_config( virtual status_t getConfig(
node_id node, OMX_INDEXTYPE index, node_id node, OMX_INDEXTYPE index,
void *params, size_t size); void *params, size_t size);
virtual status_t set_config( virtual status_t setConfig(
node_id node, OMX_INDEXTYPE index, node_id node, OMX_INDEXTYPE index,
const void *params, size_t size); const void *params, size_t size);
virtual status_t use_buffer( virtual status_t useBuffer(
node_id node, OMX_U32 port_index, const sp<IMemory> &params, node_id node, OMX_U32 port_index, const sp<IMemory> &params,
buffer_id *buffer); buffer_id *buffer);
virtual status_t allocate_buffer( virtual status_t allocateBuffer(
node_id node, OMX_U32 port_index, size_t size, node_id node, OMX_U32 port_index, size_t size,
buffer_id *buffer); buffer_id *buffer);
virtual status_t allocate_buffer_with_backup( virtual status_t allocateBufferWithBackup(
node_id node, OMX_U32 port_index, const sp<IMemory> &params, node_id node, OMX_U32 port_index, const sp<IMemory> &params,
buffer_id *buffer); buffer_id *buffer);
virtual status_t free_buffer( virtual status_t freeBuffer(
node_id node, OMX_U32 port_index, buffer_id buffer); node_id node, OMX_U32 port_index, buffer_id buffer);
virtual status_t observe_node( virtual status_t fillBuffer(node_id node, buffer_id buffer);
node_id node, const sp<IOMXObserver> &observer);
virtual status_t fill_buffer(node_id node, buffer_id buffer); virtual status_t emptyBuffer(
virtual status_t empty_buffer(
node_id node, node_id node,
buffer_id buffer, buffer_id buffer,
OMX_U32 range_offset, OMX_U32 range_length, OMX_U32 range_offset, OMX_U32 range_length,
OMX_U32 flags, OMX_TICKS timestamp); OMX_U32 flags, OMX_TICKS timestamp);
virtual status_t get_extension_index( virtual status_t getExtensionIndex(
node_id node, node_id node,
const char *parameter_name, const char *parameter_name,
OMX_INDEXTYPE *index); OMX_INDEXTYPE *index);
@@ -90,44 +91,38 @@ public:
size_t encodedWidth, size_t encodedHeight, size_t encodedWidth, size_t encodedHeight,
size_t displayWidth, size_t displayHeight); size_t displayWidth, size_t displayHeight);
private: virtual void binderDied(const wp<IBinder> &the_late_who);
static OMX_CALLBACKTYPE kCallbacks;
Mutex mLock;
struct CallbackDispatcher;
sp<CallbackDispatcher> mDispatcher;
static OMX_ERRORTYPE OnEvent(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_PTR pAppData,
OMX_IN OMX_EVENTTYPE eEvent,
OMX_IN OMX_U32 nData1,
OMX_IN OMX_U32 nData2,
OMX_IN OMX_PTR pEventData);
static OMX_ERRORTYPE OnEmptyBufferDone(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_PTR pAppData,
OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
static OMX_ERRORTYPE OnFillBufferDone(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_PTR pAppData,
OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
OMX_ERRORTYPE OnEvent( OMX_ERRORTYPE OnEvent(
NodeMeta *meta, node_id node,
OMX_IN OMX_EVENTTYPE eEvent, OMX_IN OMX_EVENTTYPE eEvent,
OMX_IN OMX_U32 nData1, OMX_IN OMX_U32 nData1,
OMX_IN OMX_U32 nData2, OMX_IN OMX_U32 nData2,
OMX_IN OMX_PTR pEventData); OMX_IN OMX_PTR pEventData);
OMX_ERRORTYPE OnEmptyBufferDone( OMX_ERRORTYPE OnEmptyBufferDone(
NodeMeta *meta, OMX_IN OMX_BUFFERHEADERTYPE *pBuffer); node_id node, OMX_IN OMX_BUFFERHEADERTYPE *pBuffer);
OMX_ERRORTYPE OnFillBufferDone( OMX_ERRORTYPE OnFillBufferDone(
NodeMeta *meta, OMX_IN OMX_BUFFERHEADERTYPE *pBuffer); node_id node, OMX_IN OMX_BUFFERHEADERTYPE *pBuffer);
void invalidateNodeID(node_id node);
private:
Mutex mLock;
struct CallbackDispatcher;
sp<CallbackDispatcher> mDispatcher;
int32_t mNodeCounter;
KeyedVector<wp<IBinder>, OMXNodeInstance *> mLiveNodes;
KeyedVector<node_id, OMXNodeInstance *> mNodeIDToInstance;
node_id makeNodeID(OMXNodeInstance *instance);
OMXNodeInstance *findInstance(node_id node);
void invalidateNodeID_l(node_id node);
OMX(const OMX &); OMX(const OMX &);
OMX &operator=(const OMX &); OMX &operator=(const OMX &);

115
media/libstagefright/include/OMXNodeInstance.h Normal file
View File

@@ -0,0 +1,115 @@
/*
* 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 OMX_NODE_INSTANCE_H_
#define OMX_NODE_INSTANCE_H_
#include "OMX.h"
#include <utils/RefBase.h>
#include <utils/threads.h>
namespace android {
class IOMXObserver;
struct OMXNodeInstance {
OMXNodeInstance(
OMX *owner, const sp<IOMXObserver> &observer);
void setHandle(OMX::node_id node_id, OMX_HANDLETYPE handle);
OMX *owner();
sp<IOMXObserver> observer();
OMX::node_id nodeID();
status_t freeNode();
status_t sendCommand(OMX_COMMANDTYPE cmd, OMX_S32 param);
status_t getParameter(OMX_INDEXTYPE index, void *params, size_t size);
status_t setParameter(
OMX_INDEXTYPE index, const void *params, size_t size);
status_t getConfig(OMX_INDEXTYPE index, void *params, size_t size);
status_t setConfig(OMX_INDEXTYPE index, const void *params, size_t size);
status_t useBuffer(
OMX_U32 portIndex, const sp<IMemory> &params,
OMX::buffer_id *buffer);
status_t allocateBuffer(
OMX_U32 portIndex, size_t size, OMX::buffer_id *buffer);
status_t allocateBufferWithBackup(
OMX_U32 portIndex, const sp<IMemory> &params,
OMX::buffer_id *buffer);
status_t freeBuffer(OMX_U32 portIndex, OMX::buffer_id buffer);
status_t fillBuffer(OMX::buffer_id buffer);
status_t emptyBuffer(
OMX::buffer_id buffer,
OMX_U32 rangeOffset, OMX_U32 rangeLength,
OMX_U32 flags, OMX_TICKS timestamp);
status_t getExtensionIndex(
const char *parameterName, OMX_INDEXTYPE *index);
void onMessage(const omx_message &msg);
void onObserverDied();
void onGetHandleFailed();
static OMX_CALLBACKTYPE kCallbacks;
private:
Mutex mLock;
OMX *mOwner;
OMX::node_id mNodeID;
OMX_HANDLETYPE mHandle;
sp<IOMXObserver> mObserver;
~OMXNodeInstance();
static OMX_ERRORTYPE OnEvent(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_PTR pAppData,
OMX_IN OMX_EVENTTYPE eEvent,
OMX_IN OMX_U32 nData1,
OMX_IN OMX_U32 nData2,
OMX_IN OMX_PTR pEventData);
static OMX_ERRORTYPE OnEmptyBufferDone(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_PTR pAppData,
OMX_IN OMX_BUFFERHEADERTYPE *pBuffer);
static OMX_ERRORTYPE OnFillBufferDone(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_PTR pAppData,
OMX_IN OMX_BUFFERHEADERTYPE *pBuffer);
OMXNodeInstance(const OMXNodeInstance &);
OMXNodeInstance &operator=(const OMXNodeInstance &);
};
} // namespace android
#endif // OMX_NODE_INSTANCE_H_

1
media/libstagefright/omx/Android.mk
View File

@@ -12,6 +12,7 @@ LOCAL_C_INCLUDES += $(JNI_H_INCLUDE)
LOCAL_SRC_FILES:= \ LOCAL_SRC_FILES:= \
ColorConverter.cpp \ ColorConverter.cpp \
OMX.cpp \ OMX.cpp \
OMXNodeInstance.cpp \
QComHardwareRenderer.cpp \ QComHardwareRenderer.cpp \
SoftwareRenderer.cpp \ SoftwareRenderer.cpp \
TIHardwareRenderer.cpp TIHardwareRenderer.cpp

394
media/libstagefright/omx/OMX.cpp
View File

@@ -18,13 +18,12 @@
#define LOG_TAG "OMX" #define LOG_TAG "OMX"
#include <utils/Log.h> #include <utils/Log.h>
#include <sys/socket.h> #include "../include/OMX.h"
#include "OMX.h"
#include "OMXRenderer.h" #include "OMXRenderer.h"
#include "pv_omxcore.h" #include "pv_omxcore.h"
#include "../include/OMXNodeInstance.h"
#include "../include/QComHardwareRenderer.h" #include "../include/QComHardwareRenderer.h"
#include "../include/SoftwareRenderer.h" #include "../include/SoftwareRenderer.h"
#include "../include/TIHardwareRenderer.h" #include "../include/TIHardwareRenderer.h"
@@ -37,47 +36,10 @@
namespace android { namespace android {
class NodeMeta {
public:
NodeMeta(OMX *owner)
: mOwner(owner),
mHandle(NULL) {
}
OMX *owner() const {
return mOwner;
}
void setHandle(OMX_HANDLETYPE handle) {
CHECK_EQ(mHandle, NULL);
mHandle = handle;
}
OMX_HANDLETYPE handle() const {
return mHandle;
}
void setObserver(const sp<IOMXObserver> &observer) {
mObserver = observer;
}
sp<IOMXObserver> observer() {
return mObserver;
}
private:
OMX *mOwner;
OMX_HANDLETYPE mHandle;
sp<IOMXObserver> mObserver;
NodeMeta(const NodeMeta &);
NodeMeta &operator=(const NodeMeta &);
};
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
struct OMX::CallbackDispatcher : public RefBase { struct OMX::CallbackDispatcher : public RefBase {
CallbackDispatcher(); CallbackDispatcher(OMX *owner);
void post(const omx_message &msg); void post(const omx_message &msg);
@@ -86,6 +48,8 @@ protected:
private: private:
Mutex mLock; Mutex mLock;
OMX *mOwner;
bool mDone; bool mDone;
Condition mQueueChanged; Condition mQueueChanged;
List<omx_message> mQueue; List<omx_message> mQueue;
@@ -101,8 +65,9 @@ private:
CallbackDispatcher &operator=(const CallbackDispatcher &); CallbackDispatcher &operator=(const CallbackDispatcher &);
}; };
OMX::CallbackDispatcher::CallbackDispatcher() OMX::CallbackDispatcher::CallbackDispatcher(OMX *owner)
: mDone(false) { : mOwner(owner),
mDone(false) {
pthread_attr_t attr; pthread_attr_t attr;
pthread_attr_init(&attr); pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
@@ -131,12 +96,12 @@ void OMX::CallbackDispatcher::post(const omx_message &msg) {
} }
void OMX::CallbackDispatcher::dispatch(const omx_message &msg) { void OMX::CallbackDispatcher::dispatch(const omx_message &msg) {
NodeMeta *meta = static_cast<NodeMeta *>(msg.node); OMXNodeInstance *instance = mOwner->findInstance(msg.node);
if (instance == NULL) {
sp<IOMXObserver> observer = meta->observer(); LOGW("Would have dispatched a message to a node that's already gone.");
if (observer.get() != NULL) { return;
observer->on_message(msg);
} }
instance->onMessage(msg);
} }
// static // static
@@ -214,46 +179,30 @@ private:
BufferMeta &operator=(const BufferMeta &); BufferMeta &operator=(const BufferMeta &);
}; };
// static
OMX_CALLBACKTYPE OMX::kCallbacks = {
&OnEvent, &OnEmptyBufferDone, &OnFillBufferDone
};
// static
OMX_ERRORTYPE OMX::OnEvent(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_PTR pAppData,
OMX_IN OMX_EVENTTYPE eEvent,
OMX_IN OMX_U32 nData1,
OMX_IN OMX_U32 nData2,
OMX_IN OMX_PTR pEventData) {
NodeMeta *meta = static_cast<NodeMeta *>(pAppData);
return meta->owner()->OnEvent(meta, eEvent, nData1, nData2, pEventData);
}
// static
OMX_ERRORTYPE OMX::OnEmptyBufferDone(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_PTR pAppData,
OMX_IN OMX_BUFFERHEADERTYPE* pBuffer) {
NodeMeta *meta = static_cast<NodeMeta *>(pAppData);
return meta->owner()->OnEmptyBufferDone(meta, pBuffer);
}
// static
OMX_ERRORTYPE OMX::OnFillBufferDone(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_PTR pAppData,
OMX_IN OMX_BUFFERHEADERTYPE* pBuffer) {
NodeMeta *meta = static_cast<NodeMeta *>(pAppData);
return meta->owner()->OnFillBufferDone(meta, pBuffer);
}
OMX::OMX() OMX::OMX()
: mDispatcher(new CallbackDispatcher) { : mDispatcher(new CallbackDispatcher(this)),
mNodeCounter(0) {
} }
status_t OMX::list_nodes(List<String8> *list) { void OMX::binderDied(const wp<IBinder> &the_late_who) {
OMXNodeInstance *instance;
{
Mutex::Autolock autoLock(mLock);
ssize_t index = mLiveNodes.indexOfKey(the_late_who);
CHECK(index >= 0);
instance = mLiveNodes.editValueAt(index);
mLiveNodes.removeItemsAt(index);
invalidateNodeID_l(instance->nodeID());
}
instance->onObserverDied();
}
status_t OMX::listNodes(List<String8> *list) {
OMX_MasterInit(); // XXX Put this somewhere else. OMX_MasterInit(); // XXX Put this somewhere else.
list->clear(); list->clear();
@@ -270,204 +219,132 @@ status_t OMX::list_nodes(List<String8> *list) {
return OK; return OK;
} }
status_t OMX::allocate_node(const char *name, node_id *node) { status_t OMX::allocateNode(
const char *name, const sp<IOMXObserver> &observer, node_id *node) {
Mutex::Autolock autoLock(mLock); Mutex::Autolock autoLock(mLock);
*node = 0; *node = 0;
OMX_MasterInit(); // XXX Put this somewhere else. OMX_MasterInit(); // XXX Put this somewhere else.
NodeMeta *meta = new NodeMeta(this); OMXNodeInstance *instance = new OMXNodeInstance(this, observer);
OMX_HANDLETYPE handle; OMX_HANDLETYPE handle;
OMX_ERRORTYPE err = OMX_MasterGetHandle( OMX_ERRORTYPE err = OMX_MasterGetHandle(
&handle, const_cast<char *>(name), meta, &kCallbacks); &handle, const_cast<char *>(name), instance,
&OMXNodeInstance::kCallbacks);
if (err != OMX_ErrorNone) { if (err != OMX_ErrorNone) {
LOGV("FAILED to allocate omx component '%s'", name); LOGV("FAILED to allocate omx component '%s'", name);
delete meta; instance->onGetHandleFailed();
meta = NULL;
return UNKNOWN_ERROR; return UNKNOWN_ERROR;
} }
meta->setHandle(handle); *node = makeNodeID(instance);
*node = meta; instance->setHandle(*node, handle);
mLiveNodes.add(observer->asBinder(), instance);
observer->asBinder()->linkToDeath(this);
return OK; return OK;
} }
status_t OMX::free_node(node_id node) { status_t OMX::freeNode(node_id node) {
Mutex::Autolock autoLock(mLock); OMXNodeInstance *instance = findInstance(node);
NodeMeta *meta = static_cast<NodeMeta *>(node); ssize_t index = mLiveNodes.indexOfKey(instance->observer()->asBinder());
CHECK(index >= 0);
mLiveNodes.removeItemsAt(index);
instance->observer()->asBinder()->unlinkToDeath(this);
OMX_ERRORTYPE err = OMX_MasterFreeHandle(meta->handle()); return instance->freeNode();
delete meta;
meta = NULL;
return (err != OMX_ErrorNone) ? UNKNOWN_ERROR : OK;
} }
status_t OMX::send_command( status_t OMX::sendCommand(
node_id node, OMX_COMMANDTYPE cmd, OMX_S32 param) { node_id node, OMX_COMMANDTYPE cmd, OMX_S32 param) {
Mutex::Autolock autoLock(mLock); return findInstance(node)->sendCommand(cmd, param);
NodeMeta *meta = static_cast<NodeMeta *>(node);
OMX_ERRORTYPE err = OMX_SendCommand(meta->handle(), cmd, param, NULL);
return (err != OMX_ErrorNone) ? UNKNOWN_ERROR : OK;
} }
status_t OMX::get_parameter( status_t OMX::getParameter(
node_id node, OMX_INDEXTYPE index, node_id node, OMX_INDEXTYPE index,
void *params, size_t size) { void *params, size_t size) {
Mutex::Autolock autoLock(mLock); return findInstance(node)->getParameter(
index, params, size);
NodeMeta *meta = static_cast<NodeMeta *>(node);
OMX_ERRORTYPE err = OMX_GetParameter(meta->handle(), index, params);
return (err != OMX_ErrorNone) ? UNKNOWN_ERROR : OK;
} }
status_t OMX::set_parameter( status_t OMX::setParameter(
node_id node, OMX_INDEXTYPE index, node_id node, OMX_INDEXTYPE index,
const void *params, size_t size) { const void *params, size_t size) {
Mutex::Autolock autoLock(mLock); return findInstance(node)->setParameter(
index, params, size);
NodeMeta *meta = static_cast<NodeMeta *>(node);
OMX_ERRORTYPE err =
OMX_SetParameter(meta->handle(), index, const_cast<void *>(params));
return (err != OMX_ErrorNone) ? UNKNOWN_ERROR : OK;
} }
status_t OMX::get_config( status_t OMX::getConfig(
node_id node, OMX_INDEXTYPE index, node_id node, OMX_INDEXTYPE index,
void *params, size_t size) { void *params, size_t size) {
Mutex::Autolock autoLock(mLock); return findInstance(node)->getConfig(
index, params, size);
NodeMeta *meta = static_cast<NodeMeta *>(node);
OMX_ERRORTYPE err = OMX_GetConfig(meta->handle(), index, params);
return (err != OMX_ErrorNone) ? UNKNOWN_ERROR : OK;
} }
status_t OMX::set_config( status_t OMX::setConfig(
node_id node, OMX_INDEXTYPE index, node_id node, OMX_INDEXTYPE index,
const void *params, size_t size) { const void *params, size_t size) {
Mutex::Autolock autoLock(mLock); return findInstance(node)->setConfig(
index, params, size);
NodeMeta *meta = static_cast<NodeMeta *>(node);
OMX_ERRORTYPE err =
OMX_SetConfig(meta->handle(), index, const_cast<void *>(params));
return (err != OMX_ErrorNone) ? UNKNOWN_ERROR : OK;
} }
status_t OMX::use_buffer( status_t OMX::useBuffer(
node_id node, OMX_U32 port_index, const sp<IMemory> &params, node_id node, OMX_U32 port_index, const sp<IMemory> &params,
buffer_id *buffer) { buffer_id *buffer) {
Mutex::Autolock autoLock(mLock); return findInstance(node)->useBuffer(
port_index, params, buffer);
BufferMeta *buffer_meta = new BufferMeta(this, params);
OMX_BUFFERHEADERTYPE *header;
NodeMeta *node_meta = static_cast<NodeMeta *>(node);
OMX_ERRORTYPE err =
OMX_UseBuffer(node_meta->handle(), &header, port_index, buffer_meta,
params->size(), static_cast<OMX_U8 *>(params->pointer()));
if (err != OMX_ErrorNone) {
LOGE("OMX_UseBuffer failed with error %d (0x%08x)", err, err);
delete buffer_meta;
buffer_meta = NULL;
*buffer = 0;
return UNKNOWN_ERROR;
}
*buffer = header;
return OK;
} }
status_t OMX::allocate_buffer( status_t OMX::allocateBuffer(
node_id node, OMX_U32 port_index, size_t size, node_id node, OMX_U32 port_index, size_t size,
buffer_id *buffer) { buffer_id *buffer) {
Mutex::Autolock autoLock(mLock); return findInstance(node)->allocateBuffer(
port_index, size, buffer);
BufferMeta *buffer_meta = new BufferMeta(this, size);
OMX_BUFFERHEADERTYPE *header;
NodeMeta *node_meta = static_cast<NodeMeta *>(node);
OMX_ERRORTYPE err =
OMX_AllocateBuffer(node_meta->handle(), &header, port_index,
buffer_meta, size);
if (err != OMX_ErrorNone) {
delete buffer_meta;
buffer_meta = NULL;
*buffer = 0;
return UNKNOWN_ERROR;
}
*buffer = header;
return OK;
} }
status_t OMX::allocate_buffer_with_backup( status_t OMX::allocateBufferWithBackup(
node_id node, OMX_U32 port_index, const sp<IMemory> &params, node_id node, OMX_U32 port_index, const sp<IMemory> &params,
buffer_id *buffer) { buffer_id *buffer) {
Mutex::Autolock autoLock(mLock); return findInstance(node)->allocateBufferWithBackup(
port_index, params, buffer);
BufferMeta *buffer_meta = new BufferMeta(this, params, true);
OMX_BUFFERHEADERTYPE *header;
NodeMeta *node_meta = static_cast<NodeMeta *>(node);
OMX_ERRORTYPE err =
OMX_AllocateBuffer(
node_meta->handle(), &header, port_index, buffer_meta,
params->size());
if (err != OMX_ErrorNone) {
delete buffer_meta;
buffer_meta = NULL;
*buffer = 0;
return UNKNOWN_ERROR;
}
*buffer = header;
return OK;
} }
status_t OMX::free_buffer(node_id node, OMX_U32 port_index, buffer_id buffer) { status_t OMX::freeBuffer(node_id node, OMX_U32 port_index, buffer_id buffer) {
OMX_BUFFERHEADERTYPE *header = (OMX_BUFFERHEADERTYPE *)buffer; return findInstance(node)->freeBuffer(
BufferMeta *buffer_meta = static_cast<BufferMeta *>(header->pAppPrivate); port_index, buffer);
}
NodeMeta *node_meta = static_cast<NodeMeta *>(node); status_t OMX::fillBuffer(node_id node, buffer_id buffer) {
OMX_ERRORTYPE err = return findInstance(node)->fillBuffer(buffer);
OMX_FreeBuffer(node_meta->handle(), port_index, header); }
delete buffer_meta; status_t OMX::emptyBuffer(
buffer_meta = NULL; node_id node,
buffer_id buffer,
OMX_U32 range_offset, OMX_U32 range_length,
OMX_U32 flags, OMX_TICKS timestamp) {
return findInstance(node)->emptyBuffer(
buffer, range_offset, range_length, flags, timestamp);
}
return (err != OMX_ErrorNone) ? UNKNOWN_ERROR : OK; status_t OMX::getExtensionIndex(
node_id node,
const char *parameter_name,
OMX_INDEXTYPE *index) {
return findInstance(node)->getExtensionIndex(
parameter_name, index);
} }
OMX_ERRORTYPE OMX::OnEvent( OMX_ERRORTYPE OMX::OnEvent(
NodeMeta *meta, node_id node,
OMX_IN OMX_EVENTTYPE eEvent, OMX_IN OMX_EVENTTYPE eEvent,
OMX_IN OMX_U32 nData1, OMX_IN OMX_U32 nData1,
OMX_IN OMX_U32 nData2, OMX_IN OMX_U32 nData2,
@@ -476,7 +353,7 @@ OMX_ERRORTYPE OMX::OnEvent(
omx_message msg; omx_message msg;
msg.type = omx_message::EVENT; msg.type = omx_message::EVENT;
msg.node = meta; msg.node = node;
msg.u.event_data.event = eEvent; msg.u.event_data.event = eEvent;
msg.u.event_data.data1 = nData1; msg.u.event_data.data1 = nData1;
msg.u.event_data.data2 = nData2; msg.u.event_data.data2 = nData2;
@@ -485,14 +362,14 @@ OMX_ERRORTYPE OMX::OnEvent(
return OMX_ErrorNone; return OMX_ErrorNone;
} }
OMX_ERRORTYPE OMX::OnEmptyBufferDone( OMX_ERRORTYPE OMX::OnEmptyBufferDone(
NodeMeta *meta, OMX_IN OMX_BUFFERHEADERTYPE *pBuffer) { node_id node, OMX_IN OMX_BUFFERHEADERTYPE *pBuffer) {
LOGV("OnEmptyBufferDone buffer=%p", pBuffer); LOGV("OnEmptyBufferDone buffer=%p", pBuffer);
omx_message msg; omx_message msg;
msg.type = omx_message::EMPTY_BUFFER_DONE; msg.type = omx_message::EMPTY_BUFFER_DONE;
msg.node = meta; msg.node = node;
msg.u.buffer_data.buffer = pBuffer; msg.u.buffer_data.buffer = pBuffer;
mDispatcher->post(msg); mDispatcher->post(msg);
@@ -501,14 +378,12 @@ OMX_ERRORTYPE OMX::OnEmptyBufferDone(
} }
OMX_ERRORTYPE OMX::OnFillBufferDone( OMX_ERRORTYPE OMX::OnFillBufferDone(
NodeMeta *meta, OMX_IN OMX_BUFFERHEADERTYPE *pBuffer) { node_id node, OMX_IN OMX_BUFFERHEADERTYPE *pBuffer) {
LOGV("OnFillBufferDone buffer=%p", pBuffer); LOGV("OnFillBufferDone buffer=%p", pBuffer);
BufferMeta *buffer_meta = static_cast<BufferMeta *>(pBuffer->pAppPrivate);
buffer_meta->CopyFromOMX(pBuffer);
omx_message msg; omx_message msg;
msg.type = omx_message::FILL_BUFFER_DONE; msg.type = omx_message::FILL_BUFFER_DONE;
msg.node = meta; msg.node = node;
msg.u.extended_buffer_data.buffer = pBuffer; msg.u.extended_buffer_data.buffer = pBuffer;
msg.u.extended_buffer_data.range_offset = pBuffer->nOffset; msg.u.extended_buffer_data.range_offset = pBuffer->nOffset;
msg.u.extended_buffer_data.range_length = pBuffer->nFilledLen; msg.u.extended_buffer_data.range_length = pBuffer->nFilledLen;
@@ -521,64 +396,31 @@ OMX_ERRORTYPE OMX::OnFillBufferDone(
return OMX_ErrorNone; return OMX_ErrorNone;
} }
status_t OMX::observe_node( OMX::node_id OMX::makeNodeID(OMXNodeInstance *instance) {
node_id node, const sp<IOMXObserver> &observer) { // mLock is already held.
NodeMeta *node_meta = static_cast<NodeMeta *>(node);
node_meta->setObserver(observer); node_id node = (node_id)++mNodeCounter;
mNodeIDToInstance.add(node, instance);
return OK; return node;
} }
status_t OMX::fill_buffer(node_id node, buffer_id buffer) { OMXNodeInstance *OMX::findInstance(node_id node) {
OMX_BUFFERHEADERTYPE *header = (OMX_BUFFERHEADERTYPE *)buffer; Mutex::Autolock autoLock(mLock);
header->nFilledLen = 0;
header->nOffset = 0;
header->nFlags = 0;
NodeMeta *node_meta = static_cast<NodeMeta *>(node); ssize_t index = mNodeIDToInstance.indexOfKey(node);
OMX_ERRORTYPE err = return index < 0 ? NULL : mNodeIDToInstance.valueAt(index);
OMX_FillThisBuffer(node_meta->handle(), header);
return (err == OMX_ErrorNone) ? OK : UNKNOWN_ERROR;
} }
status_t OMX::empty_buffer( void OMX::invalidateNodeID(node_id node) {
node_id node, Mutex::Autolock autoLock(mLock);
buffer_id buffer, invalidateNodeID_l(node);
OMX_U32 range_offset, OMX_U32 range_length,
OMX_U32 flags, OMX_TICKS timestamp) {
OMX_BUFFERHEADERTYPE *header = (OMX_BUFFERHEADERTYPE *)buffer;
header->nFilledLen = range_length;
header->nOffset = range_offset;
header->nFlags = flags;
header->nTimeStamp = timestamp;
BufferMeta *buffer_meta =
static_cast<BufferMeta *>(header->pAppPrivate);
buffer_meta->CopyToOMX(header);
NodeMeta *node_meta = static_cast<NodeMeta *>(node);
OMX_ERRORTYPE err =
OMX_EmptyThisBuffer(node_meta->handle(), header);
return (err == OMX_ErrorNone) ? OK : UNKNOWN_ERROR;
} }
status_t OMX::get_extension_index( void OMX::invalidateNodeID_l(node_id node) {
node_id node, // mLock is held.
const char *parameter_name, mNodeIDToInstance.removeItem(node);
OMX_INDEXTYPE *index) {
NodeMeta *node_meta = static_cast<NodeMeta *>(node);
OMX_ERRORTYPE err =
OMX_GetExtensionIndex(
node_meta->handle(),
const_cast<char *>(parameter_name), index);
return err == OMX_ErrorNone ? OK : UNKNOWN_ERROR;
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////

373
media/libstagefright/omx/OMXNodeInstance.cpp Normal file
View File

@@ -0,0 +1,373 @@
/*
* 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.
*/
//#define LOG_NDEBUG 0
#define LOG_TAG "OMXNodeInstance"
#include <utils/Log.h>
#include "../include/OMXNodeInstance.h"
#include "pv_omxcore.h"
#include <binder/IMemory.h>
#include <media/stagefright/MediaDebug.h>
namespace android {
struct BufferMeta {
BufferMeta(const sp<IMemory> &mem, bool is_backup = false)
: mMem(mem),
mIsBackup(is_backup) {
}
BufferMeta(size_t size)
: mSize(size),
mIsBackup(false) {
}
void CopyFromOMX(const OMX_BUFFERHEADERTYPE *header) {
if (!mIsBackup) {
return;
}
memcpy((OMX_U8 *)mMem->pointer() + header->nOffset,
header->pBuffer + header->nOffset,
header->nFilledLen);
}
void CopyToOMX(const OMX_BUFFERHEADERTYPE *header) {
if (!mIsBackup) {
return;
}
memcpy(header->pBuffer + header->nOffset,
(const OMX_U8 *)mMem->pointer() + header->nOffset,
header->nFilledLen);
}
private:
sp<IMemory> mMem;
size_t mSize;
bool mIsBackup;
BufferMeta(const BufferMeta &);
BufferMeta &operator=(const BufferMeta &);
};
// static
OMX_CALLBACKTYPE OMXNodeInstance::kCallbacks = {
&OnEvent, &OnEmptyBufferDone, &OnFillBufferDone
};
OMXNodeInstance::OMXNodeInstance(
OMX *owner, const sp<IOMXObserver> &observer)
: mOwner(owner),
mNodeID(NULL),
mHandle(NULL),
mObserver(observer) {
}
OMXNodeInstance::~OMXNodeInstance() {
CHECK_EQ(mHandle, NULL);
}
void OMXNodeInstance::setHandle(OMX::node_id node_id, OMX_HANDLETYPE handle) {
CHECK_EQ(mHandle, NULL);
mNodeID = node_id;
mHandle = handle;
}
OMX *OMXNodeInstance::owner() {
return mOwner;
}
sp<IOMXObserver> OMXNodeInstance::observer() {
return mObserver;
}
OMX::node_id OMXNodeInstance::nodeID() {
return mNodeID;
}
static status_t StatusFromOMXError(OMX_ERRORTYPE err) {
return (err == OMX_ErrorNone) ? OK : UNKNOWN_ERROR;
}
status_t OMXNodeInstance::freeNode() {
Mutex::Autolock autoLock(mLock);
OMX_ERRORTYPE err = OMX_MasterFreeHandle(mHandle);
mHandle = NULL;
if (err != OMX_ErrorNone) {
LOGE("FreeHandle FAILED with error 0x%08x.", err);
}
mOwner->invalidateNodeID(mNodeID);
mNodeID = NULL;
LOGI("OMXNodeInstance going away.");
delete this;
return StatusFromOMXError(err);
}
status_t OMXNodeInstance::sendCommand(
OMX_COMMANDTYPE cmd, OMX_S32 param) {
Mutex::Autolock autoLock(mLock);
OMX_ERRORTYPE err = OMX_SendCommand(mHandle, cmd, param, NULL);
return StatusFromOMXError(err);
}
status_t OMXNodeInstance::getParameter(
OMX_INDEXTYPE index, void *params, size_t size) {
Mutex::Autolock autoLock(mLock);
OMX_ERRORTYPE err = OMX_GetParameter(mHandle, index, params);
return StatusFromOMXError(err);
}
status_t OMXNodeInstance::setParameter(
OMX_INDEXTYPE index, const void *params, size_t size) {
Mutex::Autolock autoLock(mLock);
OMX_ERRORTYPE err = OMX_SetParameter(
mHandle, index, const_cast<void *>(params));
return StatusFromOMXError(err);
}
status_t OMXNodeInstance::getConfig(
OMX_INDEXTYPE index, void *params, size_t size) {
Mutex::Autolock autoLock(mLock);
OMX_ERRORTYPE err = OMX_GetConfig(mHandle, index, params);
return StatusFromOMXError(err);
}
status_t OMXNodeInstance::setConfig(
OMX_INDEXTYPE index, const void *params, size_t size) {
Mutex::Autolock autoLock(mLock);
OMX_ERRORTYPE err = OMX_SetConfig(
mHandle, index, const_cast<void *>(params));
return StatusFromOMXError(err);
}
status_t OMXNodeInstance::useBuffer(
OMX_U32 portIndex, const sp<IMemory> &params,
OMX::buffer_id *buffer) {
Mutex::Autolock autoLock(mLock);
BufferMeta *buffer_meta = new BufferMeta(params);
OMX_BUFFERHEADERTYPE *header;
OMX_ERRORTYPE err = OMX_UseBuffer(
mHandle, &header, portIndex, buffer_meta,
params->size(), static_cast<OMX_U8 *>(params->pointer()));
if (err != OMX_ErrorNone) {
LOGE("OMX_UseBuffer failed with error %d (0x%08x)", err, err);
delete buffer_meta;
buffer_meta = NULL;
*buffer = 0;
return UNKNOWN_ERROR;
}
*buffer = header;
return OK;
}
status_t OMXNodeInstance::allocateBuffer(
OMX_U32 portIndex, size_t size, OMX::buffer_id *buffer) {
Mutex::Autolock autoLock(mLock);
BufferMeta *buffer_meta = new BufferMeta(size);
OMX_BUFFERHEADERTYPE *header;
OMX_ERRORTYPE err = OMX_AllocateBuffer(
mHandle, &header, portIndex, buffer_meta, size);
if (err != OMX_ErrorNone) {
LOGE("OMX_AllocateBuffer failed with error %d (0x%08x)", err, err);
delete buffer_meta;
buffer_meta = NULL;
*buffer = 0;
return UNKNOWN_ERROR;
}
*buffer = header;
return OK;
}
status_t OMXNodeInstance::allocateBufferWithBackup(
OMX_U32 portIndex, const sp<IMemory> &params,
OMX::buffer_id *buffer) {
Mutex::Autolock autoLock(mLock);
BufferMeta *buffer_meta = new BufferMeta(params, true);
OMX_BUFFERHEADERTYPE *header;
OMX_ERRORTYPE err = OMX_AllocateBuffer(
mHandle, &header, portIndex, buffer_meta, params->size());
if (err != OMX_ErrorNone) {
LOGE("OMX_AllocateBuffer failed with error %d (0x%08x)", err, err);
delete buffer_meta;
buffer_meta = NULL;
*buffer = 0;
return UNKNOWN_ERROR;
}
*buffer = header;
return OK;
}
status_t OMXNodeInstance::freeBuffer(
OMX_U32 portIndex, OMX::buffer_id buffer) {
Mutex::Autolock autoLock(mLock);
OMX_BUFFERHEADERTYPE *header = (OMX_BUFFERHEADERTYPE *)buffer;
BufferMeta *buffer_meta = static_cast<BufferMeta *>(header->pAppPrivate);
OMX_ERRORTYPE err = OMX_FreeBuffer(mHandle, portIndex, header);
delete buffer_meta;
buffer_meta = NULL;
return StatusFromOMXError(err);
}
status_t OMXNodeInstance::fillBuffer(OMX::buffer_id buffer) {
Mutex::Autolock autoLock(mLock);
OMX_BUFFERHEADERTYPE *header = (OMX_BUFFERHEADERTYPE *)buffer;
header->nFilledLen = 0;
header->nOffset = 0;
header->nFlags = 0;
OMX_ERRORTYPE err = OMX_FillThisBuffer(mHandle, header);
return StatusFromOMXError(err);
}
status_t OMXNodeInstance::emptyBuffer(
OMX::buffer_id buffer,
OMX_U32 rangeOffset, OMX_U32 rangeLength,
OMX_U32 flags, OMX_TICKS timestamp) {
Mutex::Autolock autoLock(mLock);
OMX_BUFFERHEADERTYPE *header = (OMX_BUFFERHEADERTYPE *)buffer;
header->nFilledLen = rangeLength;
header->nOffset = rangeOffset;
header->nFlags = flags;
header->nTimeStamp = timestamp;
BufferMeta *buffer_meta =
static_cast<BufferMeta *>(header->pAppPrivate);
buffer_meta->CopyToOMX(header);
OMX_ERRORTYPE err = OMX_EmptyThisBuffer(mHandle, header);
return StatusFromOMXError(err);
}
status_t OMXNodeInstance::getExtensionIndex(
const char *parameterName, OMX_INDEXTYPE *index) {
Mutex::Autolock autoLock(mLock);
OMX_ERRORTYPE err = OMX_GetExtensionIndex(
mHandle, const_cast<char *>(parameterName), index);
return StatusFromOMXError(err);
}
void OMXNodeInstance::onMessage(const omx_message &msg) {
if (msg.type == omx_message::FILL_BUFFER_DONE) {
OMX_BUFFERHEADERTYPE *buffer =
static_cast<OMX_BUFFERHEADERTYPE *>(
msg.u.extended_buffer_data.buffer);
BufferMeta *buffer_meta =
static_cast<BufferMeta *>(buffer->pAppPrivate);
buffer_meta->CopyFromOMX(buffer);
}
mObserver->onMessage(msg);
}
void OMXNodeInstance::onObserverDied() {
LOGE("!!! Observer died. Quickly, do something, ... anything...");
// Try to force shutdown of the node and hope for the best.
freeNode();
}
void OMXNodeInstance::onGetHandleFailed() {
delete this;
}
// static
OMX_ERRORTYPE OMXNodeInstance::OnEvent(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_PTR pAppData,
OMX_IN OMX_EVENTTYPE eEvent,
OMX_IN OMX_U32 nData1,
OMX_IN OMX_U32 nData2,
OMX_IN OMX_PTR pEventData) {
OMXNodeInstance *instance = static_cast<OMXNodeInstance *>(pAppData);
return instance->owner()->OnEvent(
instance->nodeID(), eEvent, nData1, nData2, pEventData);
}
// static
OMX_ERRORTYPE OMXNodeInstance::OnEmptyBufferDone(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_PTR pAppData,
OMX_IN OMX_BUFFERHEADERTYPE* pBuffer) {
OMXNodeInstance *instance = static_cast<OMXNodeInstance *>(pAppData);
return instance->owner()->OnEmptyBufferDone(instance->nodeID(), pBuffer);
}
// static
OMX_ERRORTYPE OMXNodeInstance::OnFillBufferDone(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_PTR pAppData,
OMX_IN OMX_BUFFERHEADERTYPE* pBuffer) {
OMXNodeInstance *instance = static_cast<OMXNodeInstance *>(pAppData);
return instance->owner()->OnFillBufferDone(instance->nodeID(), pBuffer);
}
} // namespace android