Squashed commit of the following:

commit c80992e419ed567abef451042f09c4958534b90d
Author: Andreas Huber <andih@google.com>
Date:   Wed May 11 14:00:07 2011 -0700

    Support for the mp3 audio decoder as a software OMX component.

    Change-Id: I66e10c4d0be4c3aecdef1c21b15a2c7359ceb807

commit a358d0e1bf2a88897887445f42ccdda0f5f2f528
Author: Andreas Huber <andih@google.com>
Date:   Wed May 11 13:11:23 2011 -0700

    Support for G.711 alaw and mulaw decoders as software OMX components

    Change-Id: Ia5c76c02cb83a9f94ce39a27b2251e5880218f03

commit 79088b9c9a5c8b8c97ea66cb4f90a2b0f0d34553
Author: Andreas Huber <andih@google.com>
Date:   Thu May 5 15:43:32 2011 -0700

    Instead of using an RGB surface and conversion yuv420->rgb565

    convert from OMX_COLOR_FormatYUV420Planar to HAL_PIXEL_FORMAT_YV12 instead.

    Change-Id: I8c4fc3c54c963f0d4ba6377f3c4ab4e0013152e5
    related-to-bug: 4394005

commit 69469d3bd84425777b11b9fc938c5e0c61af26a7
Author: Andreas Huber <andih@google.com>
Date:   Tue May 10 15:46:42 2011 -0700

    voip mustn't link against libstagefright.so

    Change-Id: I4d0ba9a8b9dc9380b792a1bd04bcda231964862c

commit 2a9a9eeeeeb36ae3a9e680469c3016d509ff08c3
Author: Andreas Huber <andih@google.com>
Date:   Tue May 10 14:37:10 2011 -0700

    Remove most non-OMX software decoders by default

    Change-Id: Ic56514bc1b56b8fa952e8c4a164ea7379ecb69d0

commit a4de62c37b335c318217765403a9fb282b20a216
Author: Andreas Huber <andih@google.com>
Date:   Mon May 9 16:50:02 2011 -0700

    Conditionally build the old-style software decoders.

    Change-Id: I5de609e1d76c92d26d6eb81d1551462258f3f15f

commit 5d8b039f9449dc3dad1e77c42c80cc0b54b0c846
Author: Andreas Huber <andih@google.com>
Date:   Mon May 9 16:13:12 2011 -0700

    Support for MPEG4 and H.263 video decoders as soft OMX components.

    Change-Id: I5e3a4835afab89f98e3aa128d013628f5830eafe

commit b25a1bfbeb0ff6e62e1cc694ce2599c91489c7d0
Author: Andreas Huber <andih@google.com>
Date:   Mon May 9 11:49:10 2011 -0700

    Boost Soft OMX thread priority, fix timestamp handling in vorbis Soft OMX decoder.

    Change-Id: I68d26d4999f06fcc451d69e5303663fab0cba9e8

commit c0574362f8dc3319ce84d981097867062a698527
Author: Andreas Huber <andih@google.com>
Date:   Mon May 9 11:28:53 2011 -0700

    Support for the AMR decoders (NB and WB) as Soft OMX components.

    Change-Id: Ia565f59833fb52653e23f26536e7e41fc329a754

commit 3e5575a8f0e27a490cb7bde77bd9456087837f08
Author: Andreas Huber <andih@google.com>
Date:   Wed May 4 13:41:25 2011 -0700

    Signal an error if the aac decoder failed to initialize from codec specific data.

    Change-Id: I01da7831bdf722edd7d6dc5974486daa2cf2b209
    related-to-bug: 4272179

commit f94aeaa9886e772ff4823e671ed237096649f4af
Author: Andreas Huber <andih@google.com>
Date:   Tue May 3 13:07:38 2011 -0700

    Software OMX nodes don't (yet?) support native_window mode.

    Change-Id: I7d9ca9164ef4abf66b573ca21dba12d672f8b12d

commit eefdfabac8dc659e00daa56da69aea705c49cb67
Author: Andreas Huber <andih@google.com>
Date:   Tue May 3 12:57:16 2011 -0700

    Fixing the OMX tests to refer to appropriate files from test content.

    Change-Id: I5b61c3498749bfb876abbd3946a5132356e3f6ff

commit f31b7326aef14b6a1b7946520a9688f092e844d5
Author: Andreas Huber <andih@google.com>
Date:   Tue May 3 11:08:38 2011 -0700

    Soft OMX components are now dynamiclly loaded/unloaded, not directly linked against.

    Change-Id: I1e2ecfbfab67a8869886f738eaf0c7b3c948b6d9

commit b7f0343879e4df06f0a1c9bfece24df557954e2f
Author: Andreas Huber <andih@google.com>
Date:   Mon May 2 15:58:36 2011 -0700

    Support for the AVC software decoder as an OMX component.

    Change-Id: I13c12df435ba4afbd968a9fc659f66b91c818bc2

commit 5bb9e616d6c8e1b13d531fe996b9a9affdfb2977
Author: Andreas Huber <andih@google.com>
Date:   Fri Apr 29 12:05:37 2011 -0700

    Fix Vorbis OMX decoder's component role.

    Change-Id: I5e871e5e11b3f951c93590210e63fd7987c467b5

commit 089c91f2333062e196c7afd5fb0ca914878aa474
Author: Andreas Huber <andih@google.com>
Date:   Fri Apr 29 12:05:18 2011 -0700

    Support vorbis_decoder OMX testing.

    Change-Id: I1985be178a12ae3f8768bc72067d9236238be170

commit 56e241fa36fc37219bc536b823bdc2ab82dc1fad
Author: Andreas Huber <andih@google.com>
Date:   Fri Apr 29 12:01:46 2011 -0700

    SoftVorbis OMX component now respects the number of valid frames per page.

    Change-Id: I82a117a064d9b083fc58a54ad900a987a763ef03

commit fcd618ec520c376fdb78f4cbb44b8d9f5d213e2b
Author: Andreas Huber <andih@google.com>
Date:   Fri Apr 29 10:59:38 2011 -0700

    Support for the vorbis audio decoder as a soft OMX component.

    Change-Id: Iaeb057e58ca306d3dce205c0445b74d5aefef492

commit d1fcc3203fc8003ad79c6e96b3a1fc4261743f16
Author: Andreas Huber <andih@google.com>
Date:   Fri Apr 29 10:07:50 2011 -0700

    VPX decoder now properly resizes buffers after a port settings change.

    Change-Id: I110749a31b6cba087891d8e5dfe420830bdbf831

commit 35c7168243cb69849d88911144a2c7fdfed5c54e
Author: Andreas Huber <andih@google.com>
Date:   Thu Apr 28 13:23:34 2011 -0700

    Support for the VPX video decoder as a Software OMX component.

    Change-Id: Ic345add2d6d768d4af631160153f2e9b97fcea71

commit 923b2534b4211fc5405377b5190bfa6f2dd27f32
Author: Andreas Huber <andih@google.com>
Date:   Thu Apr 28 11:34:40 2011 -0700

    Table-based registration of soft omx components.

    Change-Id: I7f45f0fa5b3a7950776e69c66349731f7674e937

commit 04a88f3edb2266a463da9c4481b80178be460902
Author: Andreas Huber <andih@google.com>
Date:   Thu Apr 28 11:22:31 2011 -0700

    Apparently OMX_GetParameter is valid in any state other than OMX_StateInvalid

    OMX_SetParameter is still constrained to OMX_StateLoaded or a disabled port.

    Change-Id: I1032d7cf4011982d306aa369d4158a82830d26fb

commit 9d70ca68445e7c40f5c9b2d12466e468f514de88
Author: Andreas Huber <andih@google.com>
Date:   Wed Apr 27 15:03:18 2011 -0700

    Use the new soft OMX aac decoder for HTTP live playback.

    Change-Id: Ifbcfb732a9edb855cb46b49f6d0ac942170ee28f

commit 213fe4a10ea93cce08e8622dc3908053f29878a1
Author: Andreas Huber <andih@google.com>
Date:   Tue Apr 12 16:39:45 2011 -0700

    Foundation for supporting software decoders as OMX components

    Change-Id: I7fdab256563b35d1d090617abaea9a26b198d816

Change-Id: I83e9236beed4af985d10333c203f065df9e09a42

10 files changed, 1192 insertions, 152 deletions

diff --git a/media/libstagefright/omx/Android.mk b/media/libstagefright/omx/Android.mk
index 6e069c8..08ad6f3 100644
--- a/media/libstagefright/omx/Android.mk
+++ b/media/libstagefright/omx/Android.mk
@@ -1,41 +1,28 @@
 LOCAL_PATH:= $(call my-dir)
 include $(CLEAR_VARS)
 
-ifneq ($(BUILD_WITHOUT_PV),true)
-# Set up the OpenCore variables.
-include external/opencore/Config.mk
-LOCAL_C_INCLUDES := $(PV_INCLUDES)
-LOCAL_CFLAGS := $(PV_CFLAGS_MINUS_VISIBILITY)
-endif
-
 LOCAL_C_INCLUDES += $(JNI_H_INCLUDE)
 
 LOCAL_SRC_FILES:=                     \
-	OMX.cpp                       \
+        OMX.cpp                       \
         OMXComponentBase.cpp          \
+        OMXMaster.cpp                 \
         OMXNodeInstance.cpp           \
-        OMXMaster.cpp
-
-ifneq ($(BUILD_WITHOUT_PV),true)
-LOCAL_SRC_FILES += \
-        OMXPVCodecsPlugin.cpp
-else
-LOCAL_CFLAGS += -DNO_OPENCORE
-endif
-
-LOCAL_C_INCLUDES += $(TOP)/frameworks/base/include/media/stagefright/openmax
-
-LOCAL_SHARED_LIBRARIES :=       \
-        libbinder               \
-        libmedia                \
-        libutils                \
-        libui                   \
-        libcutils               \
-
-ifneq ($(BUILD_WITHOUT_PV),true)
-LOCAL_SHARED_LIBRARIES += \
-        libopencore_common
-endif
+        SimpleSoftOMXComponent.cpp    \
+        SoftOMXComponent.cpp          \
+        SoftOMXPlugin.cpp             \
+
+LOCAL_C_INCLUDES += \
+        frameworks/base/media/libstagefright \
+        $(TOP)/frameworks/base/include/media/stagefright/openmax
+
+LOCAL_SHARED_LIBRARIES :=               \
+        libbinder                       \
+        libmedia                        \
+        libutils                        \
+        libui                           \
+        libcutils                       \
+        libstagefright_foundation       \
 
 ifeq ($(TARGET_OS)-$(TARGET_SIMULATOR),linux-true)
         LOCAL_LDLIBS += -lpthread -ldl
@@ -49,5 +36,6 @@ LOCAL_MODULE:= libstagefright_omx
 
 include $(BUILD_SHARED_LIBRARY)
 
-include $(call all-makefiles-under,$(LOCAL_PATH))
+################################################################################
 
+include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/media/libstagefright/omx/OMXMaster.cpp b/media/libstagefright/omx/OMXMaster.cpp
index 56b169a..545e6d4 100644
--- a/media/libstagefright/omx/OMXMaster.cpp
+++ b/media/libstagefright/omx/OMXMaster.cpp
@@ -20,23 +20,18 @@
 
 #include "OMXMaster.h"
 
+#include "SoftOMXPlugin.h"
+
 #include <dlfcn.h>
 
 #include <media/stagefright/MediaDebug.h>
 
-#ifndef NO_OPENCORE
-#include "OMXPVCodecsPlugin.h"
-#endif
-
 namespace android {
 
 OMXMaster::OMXMaster()
     : mVendorLibHandle(NULL) {
     addVendorPlugin();
-
-#ifndef NO_OPENCORE
-    addPlugin(new OMXPVCodecsPlugin);
-#endif
+    addPlugin(new SoftOMXPlugin);
 }
 
 OMXMaster::~OMXMaster() {
@@ -49,7 +44,11 @@ OMXMaster::~OMXMaster() {
 }
 
 void OMXMaster::addVendorPlugin() {
-    mVendorLibHandle = dlopen("libstagefrighthw.so", RTLD_NOW);
+    addPlugin("libstagefrighthw.so");
+}
+
+void OMXMaster::addPlugin(const char *libname) {
+    mVendorLibHandle = dlopen(libname, RTLD_NOW);
 
     if (mVendorLibHandle == NULL) {
         return;
diff --git a/media/libstagefright/omx/OMXMaster.h b/media/libstagefright/omx/OMXMaster.h
index 7ba8d18..feee1f9 100644
--- a/media/libstagefright/omx/OMXMaster.h
+++ b/media/libstagefright/omx/OMXMaster.h
@@ -58,6 +58,7 @@ private:
     void *mVendorLibHandle;
 
     void addVendorPlugin();
+    void addPlugin(const char *libname);
     void addPlugin(OMXPluginBase *plugin);
     void clearPlugins();
 
diff --git a/media/libstagefright/omx/OMXNodeInstance.cpp b/media/libstagefright/omx/OMXNodeInstance.cpp
index cdce772..8462988 100644
--- a/media/libstagefright/omx/OMXNodeInstance.cpp
+++ b/media/libstagefright/omx/OMXNodeInstance.cpp
@@ -234,6 +234,7 @@ status_t OMXNodeInstance::getParameter(
     Mutex::Autolock autoLock(mLock);
 
     OMX_ERRORTYPE err = OMX_GetParameter(mHandle, index, params);
+
     return StatusFromOMXError(err);
 }
 
diff --git a/media/libstagefright/omx/OMXPVCodecsPlugin.cpp b/media/libstagefright/omx/OMXPVCodecsPlugin.cpp
deleted file mode 100644
index d1f5be3..0000000
--- a/media/libstagefright/omx/OMXPVCodecsPlugin.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * 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.
- */
-
-#include "OMXPVCodecsPlugin.h"
-
-#include "pv_omxcore.h"
-
-#include <media/stagefright/MediaDebug.h>
-
-namespace android {
-
-OMXPVCodecsPlugin::OMXPVCodecsPlugin() {
-    OMX_MasterInit();
-}
-
-OMXPVCodecsPlugin::~OMXPVCodecsPlugin() {
-    OMX_MasterDeinit();
-}
-
-OMX_ERRORTYPE OMXPVCodecsPlugin::makeComponentInstance(
-        const char *name,
-        const OMX_CALLBACKTYPE *callbacks,
-        OMX_PTR appData,
-        OMX_COMPONENTTYPE **component) {
-    return OMX_MasterGetHandle(
-            reinterpret_cast<OMX_HANDLETYPE *>(component),
-            const_cast<char *>(name),
-            appData,
-            const_cast<OMX_CALLBACKTYPE *>(callbacks));
-}
-
-OMX_ERRORTYPE OMXPVCodecsPlugin::destroyComponentInstance(
-        OMX_COMPONENTTYPE *component) {
-    return OMX_MasterFreeHandle(component);
-}
-
-OMX_ERRORTYPE OMXPVCodecsPlugin::enumerateComponents(
-        OMX_STRING name,
-        size_t size,
-        OMX_U32 index) {
-    return OMX_MasterComponentNameEnum(name, size, index);
-}
-
-OMX_ERRORTYPE OMXPVCodecsPlugin::getRolesOfComponent(
-        const char *name,
-        Vector<String8> *roles) {
-    roles->clear();
-
-    OMX_U32 numRoles;
-    OMX_ERRORTYPE err =
-        OMX_MasterGetRolesOfComponent(
-                const_cast<char *>(name),
-                &numRoles,
-                NULL);
-
-    if (err != OMX_ErrorNone) {
-        return err;
-    }
-
-    if (numRoles > 0) {
-        OMX_U8 **array = new OMX_U8 *[numRoles];
-        for (OMX_U32 i = 0; i < numRoles; ++i) {
-            array[i] = new OMX_U8[OMX_MAX_STRINGNAME_SIZE];
-        }
-
-        OMX_U32 numRoles2;
-        err = OMX_MasterGetRolesOfComponent(
-                const_cast<char *>(name), &numRoles2, array);
-
-        CHECK_EQ(err, OMX_ErrorNone);
-        CHECK_EQ(numRoles, numRoles2);
-
-        for (OMX_U32 i = 0; i < numRoles; ++i) {
-            String8 s((const char *)array[i]);
-            roles->push(s);
-
-            delete[] array[i];
-            array[i] = NULL;
-        }
-
-        delete[] array;
-        array = NULL;
-    }
-
-    return OMX_ErrorNone;
-}
-
-}  // namespace android
diff --git a/media/libstagefright/omx/SimpleSoftOMXComponent.cpp b/media/libstagefright/omx/SimpleSoftOMXComponent.cpp
new file mode 100644
index 0000000..179b2a0
--- /dev/null
+++ b/media/libstagefright/omx/SimpleSoftOMXComponent.cpp
@@ -0,0 +1,640 @@
+/*
+ * Copyright (C) 2011 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 "SimpleSoftOMXComponent"
+#include <utils/Log.h>
+
+#include "include/SimpleSoftOMXComponent.h"
+
+#include <media/stagefright/foundation/ADebug.h>
+#include <media/stagefright/foundation/ALooper.h>
+#include <media/stagefright/foundation/AMessage.h>
+
+namespace android {
+
+SimpleSoftOMXComponent::SimpleSoftOMXComponent(
+        const char *name,
+        const OMX_CALLBACKTYPE *callbacks,
+        OMX_PTR appData,
+        OMX_COMPONENTTYPE **component)
+    : SoftOMXComponent(name, callbacks, appData, component),
+      mLooper(new ALooper),
+      mHandler(new AHandlerReflector<SimpleSoftOMXComponent>(this)),
+      mState(OMX_StateLoaded),
+      mTargetState(OMX_StateLoaded) {
+    mLooper->setName(name);
+    mLooper->registerHandler(mHandler);
+
+    mLooper->start(
+            false, // runOnCallingThread
+            false, // canCallJava
+            PRIORITY_AUDIO);
+}
+
+SimpleSoftOMXComponent::~SimpleSoftOMXComponent() {
+    mLooper->unregisterHandler(mHandler->id());
+    mLooper->stop();
+}
+
+OMX_ERRORTYPE SimpleSoftOMXComponent::sendCommand(
+        OMX_COMMANDTYPE cmd, OMX_U32 param, OMX_PTR data) {
+    CHECK(data == NULL);
+
+    sp<AMessage> msg = new AMessage(kWhatSendCommand, mHandler->id());
+    msg->setInt32("cmd", cmd);
+    msg->setInt32("param", param);
+    msg->post();
+
+    return OMX_ErrorNone;
+}
+
+bool SimpleSoftOMXComponent::isSetParameterAllowed(
+        OMX_INDEXTYPE index, const OMX_PTR params) const {
+    if (mState == OMX_StateLoaded) {
+        return true;
+    }
+
+    OMX_U32 portIndex;
+
+    switch (index) {
+        case OMX_IndexParamPortDefinition:
+        {
+            portIndex = ((OMX_PARAM_PORTDEFINITIONTYPE *)params)->nPortIndex;
+            break;
+        }
+
+        case OMX_IndexParamAudioPcm:
+        {
+            portIndex = ((OMX_AUDIO_PARAM_PCMMODETYPE *)params)->nPortIndex;
+            break;
+        }
+
+        case OMX_IndexParamAudioAac:
+        {
+            portIndex = ((OMX_AUDIO_PARAM_AACPROFILETYPE *)params)->nPortIndex;
+            break;
+        }
+
+        default:
+            return false;
+    }
+
+    CHECK(portIndex < mPorts.size());
+
+    return !mPorts.itemAt(portIndex).mDef.bEnabled;
+}
+
+OMX_ERRORTYPE SimpleSoftOMXComponent::getParameter(
+        OMX_INDEXTYPE index, OMX_PTR params) {
+    Mutex::Autolock autoLock(mLock);
+    return internalGetParameter(index, params);
+}
+
+OMX_ERRORTYPE SimpleSoftOMXComponent::setParameter(
+        OMX_INDEXTYPE index, const OMX_PTR params) {
+    Mutex::Autolock autoLock(mLock);
+
+    CHECK(isSetParameterAllowed(index, params));
+
+    return internalSetParameter(index, params);
+}
+
+OMX_ERRORTYPE SimpleSoftOMXComponent::internalGetParameter(
+        OMX_INDEXTYPE index, OMX_PTR params) {
+    switch (index) {
+        case OMX_IndexParamPortDefinition:
+        {
+            OMX_PARAM_PORTDEFINITIONTYPE *defParams =
+                (OMX_PARAM_PORTDEFINITIONTYPE *)params;
+
+            if (defParams->nPortIndex >= mPorts.size()
+                    || defParams->nSize
+                            != sizeof(OMX_PARAM_PORTDEFINITIONTYPE)) {
+                return OMX_ErrorUndefined;
+            }
+
+            const PortInfo *port =
+                &mPorts.itemAt(defParams->nPortIndex);
+
+            memcpy(defParams, &port->mDef, sizeof(port->mDef));
+
+            return OMX_ErrorNone;
+        }
+
+        default:
+            return OMX_ErrorUnsupportedIndex;
+    }
+}
+
+OMX_ERRORTYPE SimpleSoftOMXComponent::internalSetParameter(
+        OMX_INDEXTYPE index, const OMX_PTR params) {
+    switch (index) {
+        case OMX_IndexParamPortDefinition:
+        {
+            OMX_PARAM_PORTDEFINITIONTYPE *defParams =
+                (OMX_PARAM_PORTDEFINITIONTYPE *)params;
+
+            if (defParams->nPortIndex >= mPorts.size()
+                    || defParams->nSize
+                            != sizeof(OMX_PARAM_PORTDEFINITIONTYPE)) {
+                return OMX_ErrorUndefined;
+            }
+
+            PortInfo *port =
+                &mPorts.editItemAt(defParams->nPortIndex);
+
+            if (defParams->nBufferSize != port->mDef.nBufferSize) {
+                CHECK_GE(defParams->nBufferSize, port->mDef.nBufferSize);
+                port->mDef.nBufferSize = defParams->nBufferSize;
+            }
+
+            if (defParams->nBufferCountActual
+                    != port->mDef.nBufferCountActual) {
+                CHECK_GE(defParams->nBufferCountActual,
+                         port->mDef.nBufferCountMin);
+
+                port->mDef.nBufferCountActual = defParams->nBufferCountActual;
+            }
+
+            return OMX_ErrorNone;
+        }
+
+        default:
+            return OMX_ErrorUnsupportedIndex;
+    }
+}
+
+OMX_ERRORTYPE SimpleSoftOMXComponent::useBuffer(
+        OMX_BUFFERHEADERTYPE **header,
+        OMX_U32 portIndex,
+        OMX_PTR appPrivate,
+        OMX_U32 size,
+        OMX_U8 *ptr) {
+    Mutex::Autolock autoLock(mLock);
+    CHECK_LT(portIndex, mPorts.size());
+
+    *header = new OMX_BUFFERHEADERTYPE;
+    (*header)->nSize = sizeof(OMX_BUFFERHEADERTYPE);
+    (*header)->nVersion.s.nVersionMajor = 1;
+    (*header)->nVersion.s.nVersionMinor = 0;
+    (*header)->nVersion.s.nRevision = 0;
+    (*header)->nVersion.s.nStep = 0;
+    (*header)->pBuffer = ptr;
+    (*header)->nAllocLen = size;
+    (*header)->nFilledLen = 0;
+    (*header)->nOffset = 0;
+    (*header)->pAppPrivate = appPrivate;
+    (*header)->pPlatformPrivate = NULL;
+    (*header)->pInputPortPrivate = NULL;
+    (*header)->pOutputPortPrivate = NULL;
+    (*header)->hMarkTargetComponent = NULL;
+    (*header)->pMarkData = NULL;
+    (*header)->nTickCount = 0;
+    (*header)->nTimeStamp = 0;
+    (*header)->nFlags = 0;
+    (*header)->nOutputPortIndex = portIndex;
+    (*header)->nInputPortIndex = portIndex;
+
+    PortInfo *port = &mPorts.editItemAt(portIndex);
+
+    CHECK(mState == OMX_StateLoaded || port->mDef.bEnabled == OMX_FALSE);
+
+    CHECK_LT(port->mBuffers.size(), port->mDef.nBufferCountActual);
+
+    port->mBuffers.push();
+
+    BufferInfo *buffer =
+        &port->mBuffers.editItemAt(port->mBuffers.size() - 1);
+
+    buffer->mHeader = *header;
+    buffer->mOwnedByUs = false;
+
+    if (port->mBuffers.size() == port->mDef.nBufferCountActual) {
+        port->mDef.bPopulated = OMX_TRUE;
+        checkTransitions();
+    }
+
+    return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE SimpleSoftOMXComponent::allocateBuffer(
+        OMX_BUFFERHEADERTYPE **header,
+        OMX_U32 portIndex,
+        OMX_PTR appPrivate,
+        OMX_U32 size) {
+    OMX_U8 *ptr = new OMX_U8[size];
+
+    OMX_ERRORTYPE err =
+        useBuffer(header, portIndex, appPrivate, size, ptr);
+
+    if (err != OMX_ErrorNone) {
+        delete[] ptr;
+        ptr = NULL;
+
+        return err;
+    }
+
+    CHECK((*header)->pPlatformPrivate == NULL);
+    (*header)->pPlatformPrivate = ptr;
+
+    return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE SimpleSoftOMXComponent::freeBuffer(
+        OMX_U32 portIndex,
+        OMX_BUFFERHEADERTYPE *header) {
+    Mutex::Autolock autoLock(mLock);
+
+    CHECK_LT(portIndex, mPorts.size());
+
+    PortInfo *port = &mPorts.editItemAt(portIndex);
+
+#if 0 // XXX
+    CHECK((mState == OMX_StateIdle && mTargetState == OMX_StateLoaded)
+            || port->mDef.bEnabled == OMX_FALSE);
+#endif
+
+    bool found = false;
+    for (size_t i = 0; i < port->mBuffers.size(); ++i) {
+        BufferInfo *buffer = &port->mBuffers.editItemAt(i);
+
+        if (buffer->mHeader == header) {
+            CHECK(!buffer->mOwnedByUs);
+
+            if (header->pPlatformPrivate != NULL) {
+                // This buffer's data was allocated by us.
+                CHECK(header->pPlatformPrivate == header->pBuffer);
+
+                delete[] header->pBuffer;
+                header->pBuffer = NULL;
+            }
+
+            delete header;
+            header = NULL;
+
+            port->mBuffers.removeAt(i);
+            port->mDef.bPopulated = OMX_FALSE;
+
+            checkTransitions();
+
+            found = true;
+            break;
+        }
+    }
+
+    CHECK(found);
+
+    return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE SimpleSoftOMXComponent::emptyThisBuffer(
+        OMX_BUFFERHEADERTYPE *buffer) {
+    sp<AMessage> msg = new AMessage(kWhatEmptyThisBuffer, mHandler->id());
+    msg->setPointer("header", buffer);
+    msg->post();
+
+    return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE SimpleSoftOMXComponent::fillThisBuffer(
+        OMX_BUFFERHEADERTYPE *buffer) {
+    sp<AMessage> msg = new AMessage(kWhatFillThisBuffer, mHandler->id());
+    msg->setPointer("header", buffer);
+    msg->post();
+
+    return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE SimpleSoftOMXComponent::getState(OMX_STATETYPE *state) {
+    Mutex::Autolock autoLock(mLock);
+
+    *state = mState;
+
+    return OMX_ErrorNone;
+}
+
+void SimpleSoftOMXComponent::onMessageReceived(const sp<AMessage> &msg) {
+    Mutex::Autolock autoLock(mLock);
+
+    switch (msg->what()) {
+        case kWhatSendCommand:
+        {
+            int32_t cmd, param;
+            CHECK(msg->findInt32("cmd", &cmd));
+            CHECK(msg->findInt32("param", &param));
+
+            onSendCommand((OMX_COMMANDTYPE)cmd, (OMX_U32)param);
+            break;
+        }
+
+        case kWhatEmptyThisBuffer:
+        case kWhatFillThisBuffer:
+        {
+            OMX_BUFFERHEADERTYPE *header;
+            CHECK(msg->findPointer("header", (void **)&header));
+
+            CHECK(mState == OMX_StateExecuting && mTargetState == mState);
+
+            bool found = false;
+            for (size_t i = 0; i < mPorts.size(); ++i) {
+                PortInfo *port = &mPorts.editItemAt(i);
+
+                for (size_t j = 0; j < port->mBuffers.size(); ++j) {
+                    BufferInfo *buffer = &port->mBuffers.editItemAt(j);
+
+                    if (buffer->mHeader == header) {
+                        CHECK(!buffer->mOwnedByUs);
+
+                        buffer->mOwnedByUs = true;
+
+                        CHECK((msg->what() == kWhatEmptyThisBuffer
+                                    && port->mDef.eDir == OMX_DirInput)
+                                || (port->mDef.eDir == OMX_DirOutput));
+
+                        port->mQueue.push_back(buffer);
+                        onQueueFilled(i);
+
+                        found = true;
+                        break;
+                    }
+                }
+            }
+
+            CHECK(found);
+            break;
+        }
+
+        default:
+            TRESPASS();
+            break;
+    }
+}
+
+void SimpleSoftOMXComponent::onSendCommand(
+        OMX_COMMANDTYPE cmd, OMX_U32 param) {
+    switch (cmd) {
+        case OMX_CommandStateSet:
+        {
+            onChangeState((OMX_STATETYPE)param);
+            break;
+        }
+
+        case OMX_CommandPortEnable:
+        case OMX_CommandPortDisable:
+        {
+            onPortEnable(param, cmd == OMX_CommandPortEnable);
+            break;
+        }
+
+        case OMX_CommandFlush:
+        {
+            onPortFlush(param, true /* sendFlushComplete */);
+            break;
+        }
+
+        default:
+            TRESPASS();
+            break;
+    }
+}
+
+void SimpleSoftOMXComponent::onChangeState(OMX_STATETYPE state) {
+    // We shouldn't be in a state transition already.
+    CHECK_EQ((int)mState, (int)mTargetState);
+
+    switch (mState) {
+        case OMX_StateLoaded:
+            CHECK_EQ((int)state, (int)OMX_StateIdle);
+            break;
+        case OMX_StateIdle:
+            CHECK(state == OMX_StateLoaded || state == OMX_StateExecuting);
+            break;
+        case OMX_StateExecuting:
+        {
+            CHECK_EQ((int)state, (int)OMX_StateIdle);
+
+            for (size_t i = 0; i < mPorts.size(); ++i) {
+                onPortFlush(i, false /* sendFlushComplete */);
+            }
+
+            mState = OMX_StateIdle;
+            notify(OMX_EventCmdComplete, OMX_CommandStateSet, state, NULL);
+            break;
+        }
+
+        default:
+            TRESPASS();
+    }
+
+    mTargetState = state;
+
+    checkTransitions();
+}
+
+void SimpleSoftOMXComponent::onPortEnable(OMX_U32 portIndex, bool enable) {
+    CHECK_LT(portIndex, mPorts.size());
+
+    PortInfo *port = &mPorts.editItemAt(portIndex);
+    CHECK_EQ((int)port->mTransition, (int)PortInfo::NONE);
+    CHECK(port->mDef.bEnabled == !enable);
+
+    if (!enable) {
+        port->mDef.bEnabled = OMX_FALSE;
+        port->mTransition = PortInfo::DISABLING;
+
+        for (size_t i = 0; i < port->mBuffers.size(); ++i) {
+            BufferInfo *buffer = &port->mBuffers.editItemAt(i);
+
+            if (buffer->mOwnedByUs) {
+                buffer->mOwnedByUs = false;
+
+                if (port->mDef.eDir == OMX_DirInput) {
+                    notifyEmptyBufferDone(buffer->mHeader);
+                } else {
+                    CHECK_EQ(port->mDef.eDir, OMX_DirOutput);
+                    notifyFillBufferDone(buffer->mHeader);
+                }
+            }
+        }
+
+        port->mQueue.clear();
+    } else {
+        port->mTransition = PortInfo::ENABLING;
+    }
+
+    checkTransitions();
+}
+
+void SimpleSoftOMXComponent::onPortFlush(
+        OMX_U32 portIndex, bool sendFlushComplete) {
+    if (portIndex == OMX_ALL) {
+        for (size_t i = 0; i < mPorts.size(); ++i) {
+            onPortFlush(i, sendFlushComplete);
+        }
+
+        if (sendFlushComplete) {
+            notify(OMX_EventCmdComplete, OMX_CommandFlush, OMX_ALL, NULL);
+        }
+
+        return;
+    }
+
+    CHECK_LT(portIndex, mPorts.size());
+
+    PortInfo *port = &mPorts.editItemAt(portIndex);
+    CHECK_EQ((int)port->mTransition, (int)PortInfo::NONE);
+
+    for (size_t i = 0; i < port->mBuffers.size(); ++i) {
+        BufferInfo *buffer = &port->mBuffers.editItemAt(i);
+
+        if (!buffer->mOwnedByUs) {
+            continue;
+        }
+
+        buffer->mHeader->nFilledLen = 0;
+        buffer->mHeader->nOffset = 0;
+        buffer->mHeader->nFlags = 0;
+
+        buffer->mOwnedByUs = false;
+
+        if (port->mDef.eDir == OMX_DirInput) {
+            notifyEmptyBufferDone(buffer->mHeader);
+        } else {
+            CHECK_EQ(port->mDef.eDir, OMX_DirOutput);
+
+            notifyFillBufferDone(buffer->mHeader);
+        }
+    }
+
+    port->mQueue.clear();
+
+    if (sendFlushComplete) {
+        notify(OMX_EventCmdComplete, OMX_CommandFlush, portIndex, NULL);
+
+        onPortFlushCompleted(portIndex);
+    }
+}
+
+void SimpleSoftOMXComponent::checkTransitions() {
+    if (mState != mTargetState) {
+        bool transitionComplete = true;
+
+        if (mState == OMX_StateLoaded) {
+            CHECK_EQ((int)mTargetState, (int)OMX_StateIdle);
+
+            for (size_t i = 0; i < mPorts.size(); ++i) {
+                const PortInfo &port = mPorts.itemAt(i);
+                if (port.mDef.bEnabled == OMX_FALSE) {
+                    continue;
+                }
+
+                if (port.mDef.bPopulated == OMX_FALSE) {
+                    transitionComplete = false;
+                    break;
+                }
+            }
+        } else if (mTargetState == OMX_StateLoaded) {
+            CHECK_EQ((int)mState, (int)OMX_StateIdle);
+
+            for (size_t i = 0; i < mPorts.size(); ++i) {
+                const PortInfo &port = mPorts.itemAt(i);
+                if (port.mDef.bEnabled == OMX_FALSE) {
+                    continue;
+                }
+
+                size_t n = port.mBuffers.size();
+
+                if (n > 0) {
+                    CHECK_LE(n, port.mDef.nBufferCountActual);
+
+                    if (n == port.mDef.nBufferCountActual) {
+                        CHECK_EQ((int)port.mDef.bPopulated, (int)OMX_TRUE);
+                    } else {
+                        CHECK_EQ((int)port.mDef.bPopulated, (int)OMX_FALSE);
+                    }
+
+                    transitionComplete = false;
+                    break;
+                }
+            }
+        }
+
+        if (transitionComplete) {
+            mState = mTargetState;
+
+            notify(OMX_EventCmdComplete, OMX_CommandStateSet, mState, NULL);
+        }
+    }
+
+    for (size_t i = 0; i < mPorts.size(); ++i) {
+        PortInfo *port = &mPorts.editItemAt(i);
+
+        if (port->mTransition == PortInfo::DISABLING) {
+            if (port->mBuffers.empty()) {
+                LOGV("Port %d now disabled.", i);
+
+                port->mTransition = PortInfo::NONE;
+                notify(OMX_EventCmdComplete, OMX_CommandPortDisable, i, NULL);
+
+                onPortEnableCompleted(i, false /* enabled */);
+            }
+        } else if (port->mTransition == PortInfo::ENABLING) {
+            if (port->mDef.bPopulated == OMX_TRUE) {
+                LOGV("Port %d now enabled.", i);
+
+                port->mTransition = PortInfo::NONE;
+                port->mDef.bEnabled = OMX_TRUE;
+                notify(OMX_EventCmdComplete, OMX_CommandPortEnable, i, NULL);
+
+                onPortEnableCompleted(i, true /* enabled */);
+            }
+        }
+    }
+}
+
+void SimpleSoftOMXComponent::addPort(const OMX_PARAM_PORTDEFINITIONTYPE &def) {
+    CHECK_EQ(def.nPortIndex, mPorts.size());
+
+    mPorts.push();
+    PortInfo *info = &mPorts.editItemAt(mPorts.size() - 1);
+    info->mDef = def;
+    info->mTransition = PortInfo::NONE;
+}
+
+void SimpleSoftOMXComponent::onQueueFilled(OMX_U32 portIndex) {
+}
+
+void SimpleSoftOMXComponent::onPortFlushCompleted(OMX_U32 portIndex) {
+}
+
+void SimpleSoftOMXComponent::onPortEnableCompleted(
+        OMX_U32 portIndex, bool enabled) {
+}
+
+List<SimpleSoftOMXComponent::BufferInfo *> &
+SimpleSoftOMXComponent::getPortQueue(OMX_U32 portIndex) {
+    CHECK_LT(portIndex, mPorts.size());
+    return mPorts.editItemAt(portIndex).mQueue;
+}
+
+SimpleSoftOMXComponent::PortInfo *SimpleSoftOMXComponent::editPortInfo(
+        OMX_U32 portIndex) {
+    CHECK_LT(portIndex, mPorts.size());
+    return &mPorts.editItemAt(portIndex);
+}
+
+}  // namespace android
diff --git a/media/libstagefright/omx/SoftOMXComponent.cpp b/media/libstagefright/omx/SoftOMXComponent.cpp
new file mode 100644
index 0000000..b1c34dc
--- /dev/null
+++ b/media/libstagefright/omx/SoftOMXComponent.cpp
@@ -0,0 +1,326 @@
+/*
+ * Copyright (C) 2011 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 "SoftOMXComponent"
+#include <utils/Log.h>
+
+#include "include/SoftOMXComponent.h"
+
+#include <media/stagefright/foundation/ADebug.h>
+
+namespace android {
+
+SoftOMXComponent::SoftOMXComponent(
+        const char *name,
+        const OMX_CALLBACKTYPE *callbacks,
+        OMX_PTR appData,
+        OMX_COMPONENTTYPE **component)
+    : mName(name),
+      mCallbacks(callbacks),
+      mComponent(new OMX_COMPONENTTYPE),
+      mLibHandle(NULL) {
+    mComponent->nSize = sizeof(*mComponent);
+    mComponent->nVersion.s.nVersionMajor = 1;
+    mComponent->nVersion.s.nVersionMinor = 0;
+    mComponent->nVersion.s.nRevision = 0;
+    mComponent->nVersion.s.nStep = 0;
+    mComponent->pComponentPrivate = this;
+    mComponent->pApplicationPrivate = appData;
+
+    mComponent->GetComponentVersion = NULL;
+    mComponent->SendCommand = SendCommandWrapper;
+    mComponent->GetParameter = GetParameterWrapper;
+    mComponent->SetParameter = SetParameterWrapper;
+    mComponent->GetConfig = GetConfigWrapper;
+    mComponent->SetConfig = SetConfigWrapper;
+    mComponent->GetExtensionIndex = GetExtensionIndexWrapper;
+    mComponent->GetState = GetStateWrapper;
+    mComponent->ComponentTunnelRequest = NULL;
+    mComponent->UseBuffer = UseBufferWrapper;
+    mComponent->AllocateBuffer = AllocateBufferWrapper;
+    mComponent->FreeBuffer = FreeBufferWrapper;
+    mComponent->EmptyThisBuffer = EmptyThisBufferWrapper;
+    mComponent->FillThisBuffer = FillThisBufferWrapper;
+    mComponent->SetCallbacks = NULL;
+    mComponent->ComponentDeInit = NULL;
+    mComponent->UseEGLImage = NULL;
+    mComponent->ComponentRoleEnum = NULL;
+
+    *component = mComponent;
+}
+
+SoftOMXComponent::~SoftOMXComponent() {
+    delete mComponent;
+    mComponent = NULL;
+}
+
+void SoftOMXComponent::setLibHandle(void *libHandle) {
+    CHECK(libHandle != NULL);
+    mLibHandle = libHandle;
+}
+
+void *SoftOMXComponent::libHandle() const {
+    return mLibHandle;
+}
+
+OMX_ERRORTYPE SoftOMXComponent::initCheck() const {
+    return OMX_ErrorNone;
+}
+
+const char *SoftOMXComponent::name() const {
+    return mName.c_str();
+}
+
+void SoftOMXComponent::notify(
+        OMX_EVENTTYPE event,
+        OMX_U32 data1, OMX_U32 data2, OMX_PTR data) {
+    (*mCallbacks->EventHandler)(
+            mComponent,
+            mComponent->pApplicationPrivate,
+            event,
+            data1,
+            data2,
+            data);
+}
+
+void SoftOMXComponent::notifyEmptyBufferDone(OMX_BUFFERHEADERTYPE *header) {
+    (*mCallbacks->EmptyBufferDone)(
+            mComponent, mComponent->pApplicationPrivate, header);
+}
+
+void SoftOMXComponent::notifyFillBufferDone(OMX_BUFFERHEADERTYPE *header) {
+    (*mCallbacks->FillBufferDone)(
+            mComponent, mComponent->pApplicationPrivate, header);
+}
+
+// static
+OMX_ERRORTYPE SoftOMXComponent::SendCommandWrapper(
+        OMX_HANDLETYPE component,
+        OMX_COMMANDTYPE cmd,
+        OMX_U32 param,
+        OMX_PTR data) {
+    SoftOMXComponent *me =
+        (SoftOMXComponent *)
+            ((OMX_COMPONENTTYPE *)component)->pComponentPrivate;
+
+    return me->sendCommand(cmd, param, data);
+}
+
+// static
+OMX_ERRORTYPE SoftOMXComponent::GetParameterWrapper(
+        OMX_HANDLETYPE component,
+        OMX_INDEXTYPE index,
+        OMX_PTR params) {
+    SoftOMXComponent *me =
+        (SoftOMXComponent *)
+            ((OMX_COMPONENTTYPE *)component)->pComponentPrivate;
+
+    return me->getParameter(index, params);
+}
+
+// static
+OMX_ERRORTYPE SoftOMXComponent::SetParameterWrapper(
+        OMX_HANDLETYPE component,
+        OMX_INDEXTYPE index,
+        OMX_PTR params) {
+    SoftOMXComponent *me =
+        (SoftOMXComponent *)
+            ((OMX_COMPONENTTYPE *)component)->pComponentPrivate;
+
+    return me->setParameter(index, params);
+}
+
+// static
+OMX_ERRORTYPE SoftOMXComponent::GetConfigWrapper(
+        OMX_HANDLETYPE component,
+        OMX_INDEXTYPE index,
+        OMX_PTR params) {
+    SoftOMXComponent *me =
+        (SoftOMXComponent *)
+            ((OMX_COMPONENTTYPE *)component)->pComponentPrivate;
+
+    return me->getConfig(index, params);
+}
+
+// static
+OMX_ERRORTYPE SoftOMXComponent::SetConfigWrapper(
+        OMX_HANDLETYPE component,
+        OMX_INDEXTYPE index,
+        OMX_PTR params) {
+    SoftOMXComponent *me =
+        (SoftOMXComponent *)
+            ((OMX_COMPONENTTYPE *)component)->pComponentPrivate;
+
+    return me->setConfig(index, params);
+}
+
+// static
+OMX_ERRORTYPE SoftOMXComponent::GetExtensionIndexWrapper(
+        OMX_HANDLETYPE component,
+        OMX_STRING name,
+        OMX_INDEXTYPE *index) {
+    SoftOMXComponent *me =
+        (SoftOMXComponent *)
+            ((OMX_COMPONENTTYPE *)component)->pComponentPrivate;
+
+    return me->getExtensionIndex(name, index);
+}
+
+// static
+OMX_ERRORTYPE SoftOMXComponent::UseBufferWrapper(
+        OMX_HANDLETYPE component,
+        OMX_BUFFERHEADERTYPE **buffer,
+        OMX_U32 portIndex,
+        OMX_PTR appPrivate,
+        OMX_U32 size,
+        OMX_U8 *ptr) {
+    SoftOMXComponent *me =
+        (SoftOMXComponent *)
+            ((OMX_COMPONENTTYPE *)component)->pComponentPrivate;
+
+    return me->useBuffer(buffer, portIndex, appPrivate, size, ptr);
+}
+
+// static
+OMX_ERRORTYPE SoftOMXComponent::AllocateBufferWrapper(
+        OMX_HANDLETYPE component,
+        OMX_BUFFERHEADERTYPE **buffer,
+        OMX_U32 portIndex,
+        OMX_PTR appPrivate,
+        OMX_U32 size) {
+    SoftOMXComponent *me =
+        (SoftOMXComponent *)
+            ((OMX_COMPONENTTYPE *)component)->pComponentPrivate;
+
+    return me->allocateBuffer(buffer, portIndex, appPrivate, size);
+}
+
+// static
+OMX_ERRORTYPE SoftOMXComponent::FreeBufferWrapper(
+        OMX_HANDLETYPE component,
+        OMX_U32 portIndex,
+        OMX_BUFFERHEADERTYPE *buffer) {
+    SoftOMXComponent *me =
+        (SoftOMXComponent *)
+            ((OMX_COMPONENTTYPE *)component)->pComponentPrivate;
+
+    return me->freeBuffer(portIndex, buffer);
+}
+
+// static
+OMX_ERRORTYPE SoftOMXComponent::EmptyThisBufferWrapper(
+        OMX_HANDLETYPE component,
+        OMX_BUFFERHEADERTYPE *buffer) {
+    SoftOMXComponent *me =
+        (SoftOMXComponent *)
+            ((OMX_COMPONENTTYPE *)component)->pComponentPrivate;
+
+    return me->emptyThisBuffer(buffer);
+}
+
+// static
+OMX_ERRORTYPE SoftOMXComponent::FillThisBufferWrapper(
+        OMX_HANDLETYPE component,
+        OMX_BUFFERHEADERTYPE *buffer) {
+    SoftOMXComponent *me =
+        (SoftOMXComponent *)
+            ((OMX_COMPONENTTYPE *)component)->pComponentPrivate;
+
+    return me->fillThisBuffer(buffer);
+}
+
+// static
+OMX_ERRORTYPE SoftOMXComponent::GetStateWrapper(
+        OMX_HANDLETYPE component,
+        OMX_STATETYPE *state) {
+    SoftOMXComponent *me =
+        (SoftOMXComponent *)
+            ((OMX_COMPONENTTYPE *)component)->pComponentPrivate;
+
+    return me->getState(state);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+OMX_ERRORTYPE SoftOMXComponent::sendCommand(
+        OMX_COMMANDTYPE cmd, OMX_U32 param, OMX_PTR data) {
+    return OMX_ErrorUndefined;
+}
+
+OMX_ERRORTYPE SoftOMXComponent::getParameter(
+        OMX_INDEXTYPE index, OMX_PTR params) {
+    return OMX_ErrorUndefined;
+}
+
+OMX_ERRORTYPE SoftOMXComponent::setParameter(
+        OMX_INDEXTYPE index, const OMX_PTR params) {
+    return OMX_ErrorUndefined;
+}
+
+OMX_ERRORTYPE SoftOMXComponent::getConfig(
+        OMX_INDEXTYPE index, OMX_PTR params) {
+    return OMX_ErrorUndefined;
+}
+
+OMX_ERRORTYPE SoftOMXComponent::setConfig(
+        OMX_INDEXTYPE index, const OMX_PTR params) {
+    return OMX_ErrorUndefined;
+}
+
+OMX_ERRORTYPE SoftOMXComponent::getExtensionIndex(
+        const char *name, OMX_INDEXTYPE *index) {
+    return OMX_ErrorUndefined;
+}
+
+OMX_ERRORTYPE SoftOMXComponent::useBuffer(
+        OMX_BUFFERHEADERTYPE **buffer,
+        OMX_U32 portIndex,
+        OMX_PTR appPrivate,
+        OMX_U32 size,
+        OMX_U8 *ptr) {
+    return OMX_ErrorUndefined;
+}
+
+OMX_ERRORTYPE SoftOMXComponent::allocateBuffer(
+        OMX_BUFFERHEADERTYPE **buffer,
+        OMX_U32 portIndex,
+        OMX_PTR appPrivate,
+        OMX_U32 size) {
+    return OMX_ErrorUndefined;
+}
+
+OMX_ERRORTYPE SoftOMXComponent::freeBuffer(
+        OMX_U32 portIndex,
+        OMX_BUFFERHEADERTYPE *buffer) {
+    return OMX_ErrorUndefined;
+}
+
+OMX_ERRORTYPE SoftOMXComponent::emptyThisBuffer(
+        OMX_BUFFERHEADERTYPE *buffer) {
+    return OMX_ErrorUndefined;
+}
+
+OMX_ERRORTYPE SoftOMXComponent::fillThisBuffer(
+        OMX_BUFFERHEADERTYPE *buffer) {
+    return OMX_ErrorUndefined;
+}
+
+OMX_ERRORTYPE SoftOMXComponent::getState(OMX_STATETYPE *state) {
+    return OMX_ErrorUndefined;
+}
+
+}  // namespace android
diff --git a/media/libstagefright/omx/SoftOMXPlugin.cpp b/media/libstagefright/omx/SoftOMXPlugin.cpp
new file mode 100644
index 0000000..6bd6624
--- /dev/null
+++ b/media/libstagefright/omx/SoftOMXPlugin.cpp
@@ -0,0 +1,170 @@
+/*
+ * Copyright (C) 2011 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 "SoftOMXPlugin"
+#include <utils/Log.h>
+
+#include "SoftOMXPlugin.h"
+#include "include/SoftOMXComponent.h"
+
+#include <media/stagefright/foundation/AString.h>
+
+#include <dlfcn.h>
+
+namespace android {
+
+static const struct {
+    const char *mName;
+    const char *mLibNameSuffix;
+    const char *mRole;
+
+} kComponents[] = {
+    { "OMX.google.aac.decoder", "aacdec", "audio_decoder.aac" },
+    { "OMX.google.amrnb.decoder", "amrdec", "audio_decoder.amrnb" },
+    { "OMX.google.amrwb.decoder", "amrdec", "audio_decoder.amrwb" },
+    { "OMX.google.avc.decoder", "avcdec", "video_decoder.avc" },
+    { "OMX.google.g711.alaw.decoder", "g711dec", "audio_decoder.g711alaw" },
+    { "OMX.google.g711.mlaw.decoder", "g711dec", "audio_decoder.g711mlaw" },
+    { "OMX.google.h263.decoder", "mpeg4dec", "video_decoder.h263" },
+    { "OMX.google.mpeg4.decoder", "mpeg4dec", "video_decoder.mpeg4" },
+    { "OMX.google.mp3.decoder", "mp3dec", "audio_decoder.mp3" },
+    { "OMX.google.vorbis.decoder", "vorbisdec", "audio_decoder.vorbis" },
+    { "OMX.google.vpx.decoder", "vpxdec", "video_decoder.vpx" },
+};
+
+static const size_t kNumComponents =
+    sizeof(kComponents) / sizeof(kComponents[0]);
+
+SoftOMXPlugin::SoftOMXPlugin() {
+}
+
+OMX_ERRORTYPE SoftOMXPlugin::makeComponentInstance(
+        const char *name,
+        const OMX_CALLBACKTYPE *callbacks,
+        OMX_PTR appData,
+        OMX_COMPONENTTYPE **component) {
+    LOGV("makeComponentInstance '%s'", name);
+
+    for (size_t i = 0; i < kNumComponents; ++i) {
+        if (strcmp(name, kComponents[i].mName)) {
+            continue;
+        }
+
+        AString libName = "libstagefright_soft_";
+        libName.append(kComponents[i].mLibNameSuffix);
+        libName.append(".so");
+
+        void *libHandle = dlopen(libName.c_str(), RTLD_NOW);
+
+        if (libHandle == NULL) {
+            LOGE("unable to dlopen %s", libName.c_str());
+
+            return OMX_ErrorComponentNotFound;
+        }
+
+        typedef SoftOMXComponent *(*CreateSoftOMXComponentFunc)(
+                const char *, const OMX_CALLBACKTYPE *,
+                OMX_PTR, OMX_COMPONENTTYPE **);
+
+        CreateSoftOMXComponentFunc createSoftOMXComponent =
+            (CreateSoftOMXComponentFunc)dlsym(
+                    libHandle,
+                    "_Z22createSoftOMXComponentPKcPK16OMX_CALLBACKTYPE"
+                    "PvPP17OMX_COMPONENTTYPE");
+
+        if (createSoftOMXComponent == NULL) {
+            dlclose(libHandle);
+            libHandle = NULL;
+
+            return OMX_ErrorComponentNotFound;
+        }
+
+        sp<SoftOMXComponent> codec =
+            (*createSoftOMXComponent)(name, callbacks, appData, component);
+
+        if (codec == NULL) {
+            dlclose(libHandle);
+            libHandle = NULL;
+
+            return OMX_ErrorInsufficientResources;
+        }
+
+        OMX_ERRORTYPE err = codec->initCheck();
+        if (err != OMX_ErrorNone) {
+            dlclose(libHandle);
+            libHandle = NULL;
+
+            return err;
+        }
+
+        codec->incStrong(this);
+        codec->setLibHandle(libHandle);
+
+        return OMX_ErrorNone;
+    }
+
+    return OMX_ErrorInvalidComponentName;
+}
+
+OMX_ERRORTYPE SoftOMXPlugin::destroyComponentInstance(
+        OMX_COMPONENTTYPE *component) {
+    SoftOMXComponent *me =
+        (SoftOMXComponent *)
+            ((OMX_COMPONENTTYPE *)component)->pComponentPrivate;
+
+    void *libHandle = me->libHandle();
+
+    me->decStrong(this);
+    me = NULL;
+
+    dlclose(libHandle);
+    libHandle = NULL;
+
+    return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE SoftOMXPlugin::enumerateComponents(
+        OMX_STRING name,
+        size_t size,
+        OMX_U32 index) {
+    if (index >= kNumComponents) {
+        return OMX_ErrorNoMore;
+    }
+
+    strcpy(name, kComponents[index].mName);
+
+    return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE SoftOMXPlugin::getRolesOfComponent(
+        const char *name,
+        Vector<String8> *roles) {
+    for (size_t i = 0; i < kNumComponents; ++i) {
+        if (strcmp(name, kComponents[i].mName)) {
+            continue;
+        }
+
+        roles->clear();
+        roles->push(String8(kComponents[i].mRole));
+
+        return OMX_ErrorNone;
+    }
+
+    return OMX_ErrorInvalidComponentName;
+}
+
+}  // namespace android
diff --git a/media/libstagefright/omx/OMXPVCodecsPlugin.h b/media/libstagefright/omx/SoftOMXPlugin.h
index c133232..f93c323 100644
--- a/media/libstagefright/omx/OMXPVCodecsPlugin.h
+++ b/media/libstagefright/omx/SoftOMXPlugin.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009 The Android Open Source Project
+ * Copyright (C) 2011 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.
@@ -14,17 +14,17 @@
  * limitations under the License.
  */
 
-#ifndef OMX_PV_CODECS_PLUGIN_H_
+#ifndef SOFT_OMX_PLUGIN_H_
 
-#define OMX_PV_CODECS_PLUGIN_H_
+#define SOFT_OMX_PLUGIN_H_
 
+#include <media/stagefright/foundation/ABase.h>
 #include <media/stagefright/OMXPluginBase.h>
 
 namespace android {
 
-struct OMXPVCodecsPlugin : public OMXPluginBase {
-    OMXPVCodecsPlugin();
-    virtual ~OMXPVCodecsPlugin();
+struct SoftOMXPlugin : public OMXPluginBase {
+    SoftOMXPlugin();
 
     virtual OMX_ERRORTYPE makeComponentInstance(
             const char *name,
@@ -45,10 +45,9 @@ struct OMXPVCodecsPlugin : public OMXPluginBase {
             Vector<String8> *roles);
 
 private:
-    OMXPVCodecsPlugin(const OMXPVCodecsPlugin &);
-    OMXPVCodecsPlugin &operator=(const OMXPVCodecsPlugin &);
+    DISALLOW_EVIL_CONSTRUCTORS(SoftOMXPlugin);
 };
 
 }  // namespace android
 
-#endif  // OMX_PV_CODECS_PLUGIN_H_
+#endif  // SOFT_OMX_PLUGIN_H_
diff --git a/media/libstagefright/omx/tests/OMXHarness.cpp b/media/libstagefright/omx/tests/OMXHarness.cpp
index 54c0d77..a404f1f 100644
--- a/media/libstagefright/omx/tests/OMXHarness.cpp
+++ b/media/libstagefright/omx/tests/OMXHarness.cpp
@@ -29,6 +29,7 @@
 #include <media/stagefright/DataSource.h>
 #include <media/stagefright/MediaBuffer.h>
 #include <media/stagefright/MediaDebug.h>
+#include <media/stagefright/MediaDefs.h>
 #include <media/stagefright/MediaErrors.h>
 #include <media/stagefright/MediaExtractor.h>
 #include <media/stagefright/MediaSource.h>
@@ -454,6 +455,7 @@ static const char *GetMimeFromComponentRole(const char *componentRole) {
         { "video_decoder.avc", "video/avc" },
         { "video_decoder.mpeg4", "video/mp4v-es" },
         { "video_decoder.h263", "video/3gpp" },
+        { "video_decoder.vpx", "video/x-vnd.on2.vp8" },
 
         // we appear to use this as a synonym to amrnb.
         { "audio_decoder.amr", "audio/3gpp" },
@@ -461,7 +463,10 @@ static const char *GetMimeFromComponentRole(const char *componentRole) {
         { "audio_decoder.amrnb", "audio/3gpp" },
         { "audio_decoder.amrwb", "audio/amr-wb" },
         { "audio_decoder.aac", "audio/mp4a-latm" },
-        { "audio_decoder.mp3", "audio/mpeg" }
+        { "audio_decoder.mp3", "audio/mpeg" },
+        { "audio_decoder.vorbis", "audio/vorbis" },
+        { "audio_decoder.g711alaw", MEDIA_MIMETYPE_AUDIO_G711_ALAW },
+        { "audio_decoder.g711mlaw", MEDIA_MIMETYPE_AUDIO_G711_MLAW },
     };
 
     for (size_t i = 0; i < sizeof(kRoleToMime) / sizeof(kRoleToMime[0]); ++i) {
@@ -492,7 +497,15 @@ static const char *GetURLForMime(const char *mime) {
         { "audio/mp4a-latm",
           "file:///sdcard/media_api/video/H264_AAC.3gp" },
         { "audio/mpeg",
-          "file:///sdcard/media_api/music/MP3CBR.mp3" }
+          "file:///sdcard/media_api/music/MP3CBR.mp3" },
+        { "audio/vorbis",
+          "file:///sdcard/media_api/metaDataTestMedias/OGG/"
+          "When You Say Nothing At All.ogg" },
+        { "video/x-vnd.on2.vp8",
+          "file:///sdcard/media_api/webm/big-buck-bunny_trailer.webm" },
+        { MEDIA_MIMETYPE_AUDIO_G711_ALAW, "file:///sdcard/M1F1-Alaw-AFsp.wav" },
+        { MEDIA_MIMETYPE_AUDIO_G711_MLAW,
+          "file:///sdcard/M1F1-mulaw-AFsp.wav" },
     };
 
     for (size_t i = 0; i < sizeof(kMimeToURL) / sizeof(kMimeToURL[0]); ++i) {
@@ -746,6 +759,10 @@ status_t Harness::testAll() {
         const IOMX::ComponentInfo &info = *it;
         const char *componentName = info.mName.string();
 
+        if (strncmp(componentName, "OMX.google.", 11)) {
+            continue;
+        }
+
         for (List<String8>::const_iterator role_it = info.mRoles.begin();
              role_it != info.mRoles.end(); ++role_it) {
             const char *componentRole = (*role_it).string();