S5PC11X: OVERLAY: Added stagefright H/W renderer

- add libstagefrighthw source
- register PRODUCT_PACKAGES of device.mk

Change-Id: Iab81690734042c8e810becd1bb67f29c3835206c
Signed-off-by: hoony.yu <hoony.yu@samsung.com>

6 files changed, 585 insertions, 0 deletions

diff --git a/libstagefrighthw/Android.mk b/libstagefrighthw/Android.mk
new file mode 100644
index 0000000..6eff99b
--- /dev/null
+++ b/libstagefrighthw/Android.mk
@@ -0,0 +1,32 @@
+ifeq ($(TARGET_DEVICE),crespo)
+
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := \
+    stagefright_overlay_output.cpp \
+    SecHardwareRenderer.cpp \
+    SEC_OMX_Plugin.cpp
+
+LOCAL_CFLAGS += $(PV_CFLAGS_MINUS_VISIBILITY)
+
+LOCAL_C_INCLUDES:= \
+      $(TOP)/external/opencore/extern_libs_v2/khronos/openmax/include \
+      $(LOCAL_PATH)/../include \
+      $(LOCAL_PATH)/../liboverlay
+
+LOCAL_SHARED_LIBRARIES :=    \
+        libbinder            \
+        libutils             \
+        libcutils            \
+        libui                \
+        libdl                \
+        libsurfaceflinger_client
+
+LOCAL_MODULE := libstagefrighthw
+
+LOCAL_MODULE_TAGS := optional
+include $(BUILD_SHARED_LIBRARY)
+
+endif
+
diff --git a/libstagefrighthw/SEC_OMX_Plugin.cpp b/libstagefrighthw/SEC_OMX_Plugin.cpp
new file mode 100644
index 0000000..39b4220
--- /dev/null
+++ b/libstagefrighthw/SEC_OMX_Plugin.cpp
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2010 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 "SEC_OMX_Plugin.h"
+
+#include <dlfcn.h>
+
+#include <media/stagefright/HardwareAPI.h>
+#include <media/stagefright/MediaDebug.h>
+
+namespace android {
+
+OMXPluginBase *createOMXPlugin() {
+    return new SECOMXPlugin;
+}
+
+SECOMXPlugin::SECOMXPlugin()
+    : mLibHandle(dlopen("libSEC_OMX_Core.so", RTLD_NOW)),
+      mInit(NULL),
+      mDeinit(NULL),
+      mComponentNameEnum(NULL),
+      mGetHandle(NULL),
+      mFreeHandle(NULL),
+      mGetRolesOfComponentHandle(NULL) {
+    if (mLibHandle != NULL) {
+        mInit = (InitFunc)dlsym(mLibHandle, "SEC_OMX_Init");
+        mDeinit = (DeinitFunc)dlsym(mLibHandle, "SEC_OMX_DeInit");
+
+        mComponentNameEnum =
+            (ComponentNameEnumFunc)dlsym(mLibHandle, "SEC_OMX_ComponentNameEnum");
+
+        mGetHandle = (GetHandleFunc)dlsym(mLibHandle, "SEC_OMX_GetHandle");
+        mFreeHandle = (FreeHandleFunc)dlsym(mLibHandle, "SEC_OMX_FreeHandle");
+
+        mGetRolesOfComponentHandle =
+            (GetRolesOfComponentFunc)dlsym(
+                    mLibHandle, "SEC_OMX_GetRolesOfComponent");
+
+        (*mInit)();
+
+    }
+}
+
+SECOMXPlugin::~SECOMXPlugin() {
+    if (mLibHandle != NULL) {
+        (*mDeinit)();
+
+        dlclose(mLibHandle);
+        mLibHandle = NULL;
+    }
+}
+
+OMX_ERRORTYPE SECOMXPlugin::makeComponentInstance(
+        const char *name,
+        const OMX_CALLBACKTYPE *callbacks,
+        OMX_PTR appData,
+        OMX_COMPONENTTYPE **component) {
+    if (mLibHandle == NULL) {
+        return OMX_ErrorUndefined;
+    }
+
+    return (*mGetHandle)(
+            reinterpret_cast<OMX_HANDLETYPE *>(component),
+            const_cast<char *>(name),
+            appData, const_cast<OMX_CALLBACKTYPE *>(callbacks));
+}
+
+OMX_ERRORTYPE SECOMXPlugin::destroyComponentInstance(
+        OMX_COMPONENTTYPE *component) {
+    if (mLibHandle == NULL) {
+        return OMX_ErrorUndefined;
+    }
+
+    return (*mFreeHandle)(reinterpret_cast<OMX_HANDLETYPE *>(component));
+}
+
+OMX_ERRORTYPE SECOMXPlugin::enumerateComponents(
+        OMX_STRING name,
+        size_t size,
+        OMX_U32 index) {
+    if (mLibHandle == NULL) {
+        return OMX_ErrorUndefined;
+    }
+
+    return (*mComponentNameEnum)(name, size, index);
+}
+
+OMX_ERRORTYPE SECOMXPlugin::getRolesOfComponent(
+        const char *name,
+        Vector<String8> *roles) {
+    roles->clear();
+
+    if (mLibHandle == NULL) {
+        return OMX_ErrorUndefined;
+    }
+
+    OMX_U32 numRoles;
+    OMX_ERRORTYPE err = (*mGetRolesOfComponentHandle)(
+            const_cast<OMX_STRING>(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 = (*mGetRolesOfComponentHandle)(
+                const_cast<OMX_STRING>(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/libstagefrighthw/SEC_OMX_Plugin.h b/libstagefrighthw/SEC_OMX_Plugin.h
new file mode 100644
index 0000000..6df2d31
--- /dev/null
+++ b/libstagefrighthw/SEC_OMX_Plugin.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2010 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 SEC_OMX_PLUGIN
+
+#define SEC_OMX_PLUGIN
+
+#include <media/stagefright/OMXPluginBase.h>
+
+namespace android {
+
+struct SECOMXPlugin : public OMXPluginBase {
+    SECOMXPlugin();
+    virtual ~SECOMXPlugin();
+
+    virtual OMX_ERRORTYPE makeComponentInstance(
+            const char *name,
+            const OMX_CALLBACKTYPE *callbacks,
+            OMX_PTR appData,
+            OMX_COMPONENTTYPE **component);
+
+    virtual OMX_ERRORTYPE destroyComponentInstance(
+            OMX_COMPONENTTYPE *component);
+
+    virtual OMX_ERRORTYPE enumerateComponents(
+            OMX_STRING name,
+            size_t size,
+            OMX_U32 index);
+
+    virtual OMX_ERRORTYPE getRolesOfComponent(
+            const char *name,
+            Vector<String8> *roles);
+
+private:
+    void *mLibHandle;
+
+    typedef OMX_ERRORTYPE (*InitFunc)();
+    typedef OMX_ERRORTYPE (*DeinitFunc)();
+    typedef OMX_ERRORTYPE (*ComponentNameEnumFunc)(
+            OMX_STRING, OMX_U32, OMX_U32);
+
+    typedef OMX_ERRORTYPE (*GetHandleFunc)(
+            OMX_HANDLETYPE *, OMX_STRING, OMX_PTR, OMX_CALLBACKTYPE *);
+
+    typedef OMX_ERRORTYPE (*FreeHandleFunc)(OMX_HANDLETYPE *);
+
+    typedef OMX_ERRORTYPE (*GetRolesOfComponentFunc)(
+            OMX_STRING, OMX_U32 *, OMX_U8 **);
+
+    InitFunc mInit;
+    DeinitFunc mDeinit;
+    ComponentNameEnumFunc mComponentNameEnum;
+    GetHandleFunc mGetHandle;
+    FreeHandleFunc mFreeHandle;
+    GetRolesOfComponentFunc mGetRolesOfComponentHandle;
+
+    SECOMXPlugin(const SECOMXPlugin &);
+    SECOMXPlugin &operator=(const SECOMXPlugin &);
+};
+
+}  // namespace android
+
+#endif  // SEC_OMX_PLUGIN
diff --git a/libstagefrighthw/SecHardwareRenderer.cpp b/libstagefrighthw/SecHardwareRenderer.cpp
new file mode 100644
index 0000000..28a589b
--- /dev/null
+++ b/libstagefrighthw/SecHardwareRenderer.cpp
@@ -0,0 +1,208 @@
+/*
+ * Copyright (C) 2010 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_TAG "SecHardwareRenderer"
+#define LOG_NDEBUG 0
+#include <utils/Log.h>
+
+#include "SecHardwareRenderer.h"
+
+#include <media/stagefright/MediaDebug.h>
+#include <surfaceflinger/ISurface.h>
+#include <ui/Overlay.h>
+
+#include <hardware/hardware.h>
+
+#include "v4l2_utils.h"
+#include "utils/Timers.h"
+
+#define CACHEABLE_BUFFERS 0x1
+
+#define USE_ZERO_COPY
+//#define SEC_DEBUG
+
+namespace android {
+
+////////////////////////////////////////////////////////////////////////////////
+
+SecHardwareRenderer::SecHardwareRenderer(
+        const sp<ISurface> &surface,
+        size_t displayWidth, size_t displayHeight,
+        size_t decodedWidth, size_t decodedHeight,
+        OMX_COLOR_FORMATTYPE colorFormat)
+    : mISurface(surface),
+      mDisplayWidth(displayWidth),
+      mDisplayHeight(displayHeight),
+      mDecodedWidth(decodedWidth),
+      mDecodedHeight(decodedHeight),
+      mColorFormat(colorFormat),
+      mInitCheck(NO_INIT),
+      mFrameSize(mDecodedWidth * mDecodedHeight * 2),
+      mIsFirstFrame(true),
+      mCustomFormat(false),
+      mIndex(0) {
+
+    CHECK(mISurface.get() != NULL);
+    CHECK(mDecodedWidth > 0);
+    CHECK(mDecodedHeight > 0);
+
+    if (colorFormat != OMX_COLOR_FormatCbYCrY
+            && colorFormat != OMX_COLOR_FormatYUV420Planar
+            && colorFormat != OMX_COLOR_FormatYUV420SemiPlanar) {
+        LOGE("Invalid colorFormat (0x%x)", colorFormat);
+        return;
+    }
+
+#if defined (USE_ZERO_COPY)
+    sp<OverlayRef> ref = mISurface->createOverlay(
+            mDecodedWidth, mDecodedHeight, HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP, 0);
+    mCustomFormat = true;
+#else
+    sp<OverlayRef> ref = mISurface->createOverlay(
+            mDecodedWidth, mDecodedHeight, HAL_PIXEL_FORMAT_YCbCr_420_P, 0);
+#endif
+
+    if (ref.get() == NULL) {
+        LOGE("Unable to create the overlay!");
+        return;
+    }
+
+    mOverlay = new Overlay(ref);
+    mOverlay->setParameter(CACHEABLE_BUFFERS, 0);
+
+    mNumBuf = mOverlay->getBufferCount();
+
+    if (mCustomFormat) {
+        mFrameSize = 32;
+        mMemoryHeap = new MemoryHeapBase(mNumBuf * mFrameSize);
+    } else {
+        for (size_t i = 0; i < (size_t)mNumBuf; ++i) {
+            void *addr = mOverlay->getBufferAddress((void *)i);
+            mOverlayAddresses.push(addr);
+        }
+    }
+
+    mInitCheck = OK;
+}
+
+SecHardwareRenderer::~SecHardwareRenderer() {
+
+    if(mMemoryHeap != NULL)
+        mMemoryHeap.clear();
+
+    if (mOverlay.get() != NULL) {
+        mOverlay->destroy();
+        mOverlay.clear();
+    }
+}
+
+void SecHardwareRenderer::handleYUV420Planar(
+        const void *data, size_t size) {
+
+    int FrameSize;
+    uint8_t* pPhyYAddr;
+    uint8_t* pPhyCAddr;
+    int AddrSize;
+    size_t offset;
+
+    CHECK(size >= (mDecodedWidth * mDecodedHeight * 3) / 2);
+
+    offset = mIndex * mFrameSize;
+    void *dst = (uint8_t *)mMemoryHeap->getBase() + offset;
+
+    AddrSize = sizeof(void *);
+    memcpy(&FrameSize, data, sizeof(FrameSize));
+    memcpy(&pPhyYAddr, data + sizeof(FrameSize), sizeof(pPhyYAddr));
+    memcpy(&pPhyCAddr, data + sizeof(FrameSize) + (AddrSize * 1), sizeof(pPhyCAddr));
+
+    memcpy(dst , &pPhyYAddr, sizeof(pPhyYAddr));
+    memcpy(dst  + sizeof(pPhyYAddr) , &pPhyCAddr, sizeof(pPhyCAddr));
+    memcpy(dst  + sizeof(pPhyYAddr) + sizeof(pPhyCAddr), &mIndex, sizeof(mIndex));
+}
+
+void SecHardwareRenderer::render(
+        const void *data, size_t size, void *platformPrivate) {
+
+    if (mOverlay.get() == NULL) {
+        return;
+    }
+
+    if (mCustomFormat) {
+        /* zero copy solution case */
+
+        overlay_buffer_t dst = (uint8_t *)mMemoryHeap->getBase() + mIndex*mFrameSize;
+
+        if (mColorFormat == OMX_COLOR_FormatYUV420Planar ||
+            mColorFormat == OMX_COLOR_FormatYUV420SemiPlanar) {
+            handleYUV420Planar(data, size);
+        }
+
+        if (mOverlay->queueBuffer(dst) == ALL_BUFFERS_FLUSHED) {
+           mIsFirstFrame = true;
+           if (mOverlay->queueBuffer((void *)dst) != 0) {
+                return;
+           }
+        }
+
+        if (++mIndex == mNumBuf) {
+            mIndex = 0;
+        }
+
+        overlay_buffer_t overlay_buffer;
+        if (!mIsFirstFrame) {
+            status_t err = mOverlay->dequeueBuffer(&overlay_buffer);
+            if (err == ALL_BUFFERS_FLUSHED) {
+                mIsFirstFrame = true;
+            } else {
+                return;
+            }
+        } else {
+            mIsFirstFrame = false;
+        }
+    } else {
+        /* normal frame case */
+        if (mColorFormat == OMX_COLOR_FormatYUV420Planar) {
+            memcpy(mOverlayAddresses[mIndex], data, size);
+        }
+
+        if (mOverlay->queueBuffer((void *)mIndex) == ALL_BUFFERS_FLUSHED) {
+            mIsFirstFrame = true;
+            if (mOverlay->queueBuffer((void *)mIndex) != 0) {
+                return;
+            }
+        }
+
+        if (++mIndex == mNumBuf) {
+            mIndex = 0;
+        }
+
+        overlay_buffer_t overlay_buffer;
+        if (!mIsFirstFrame) {
+            status_t err = mOverlay->dequeueBuffer(&overlay_buffer);
+
+            if (err == ALL_BUFFERS_FLUSHED) {
+                mIsFirstFrame = true;
+            } else {
+                return;
+            }
+        } else {
+            mIsFirstFrame = false;
+        }
+    }
+}
+
+}  // namespace android
+
diff --git a/libstagefrighthw/SecHardwareRenderer.h b/libstagefrighthw/SecHardwareRenderer.h
new file mode 100644
index 0000000..a353cd6
--- /dev/null
+++ b/libstagefrighthw/SecHardwareRenderer.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2010 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 SEC_HARDWARE_RENDERER_H_
+
+#define SEC_HARDWARE_RENDERER_H_
+
+#include <media/stagefright/VideoRenderer.h>
+#include <utils/RefBase.h>
+#include <utils/Vector.h>
+
+#include <OMX_Component.h>
+
+#include <binder/MemoryHeapBase.h>
+#include <binder/MemoryHeapPmem.h>
+
+namespace android {
+
+class ISurface;
+class Overlay;
+
+class SecHardwareRenderer : public VideoRenderer {
+public:
+    SecHardwareRenderer(
+            const sp<ISurface> &surface,
+            size_t displayWidth, size_t displayHeight,
+            size_t decodedWidth, size_t decodedHeight,
+            OMX_COLOR_FORMATTYPE colorFormat);
+
+    virtual ~SecHardwareRenderer();
+
+    status_t initCheck() const { return mInitCheck; }
+
+    virtual void render(
+            const void *data, size_t size, void *platformPrivate);
+
+
+private:
+    sp<ISurface> mISurface;
+    size_t mDisplayWidth, mDisplayHeight;
+    size_t mDecodedWidth, mDecodedHeight;
+    OMX_COLOR_FORMATTYPE mColorFormat;
+    status_t mInitCheck;
+    size_t mFrameSize;
+    sp<Overlay> mOverlay;
+    sp<MemoryHeapBase> mMemoryHeap;
+    Vector<void *> mOverlayAddresses;
+    bool mIsFirstFrame;
+    int mNumBuf;
+    size_t mIndex;
+    bool mCustomFormat;
+
+
+    SecHardwareRenderer(const SecHardwareRenderer &);
+    SecHardwareRenderer &operator=(const SecHardwareRenderer &);
+
+    void handleYUV420Planar(const void *, size_t);
+};
+
+}  // namespace android
+
+#endif  // SEC_HARDWARE_RENDERER_H_
+
diff --git a/libstagefrighthw/stagefright_overlay_output.cpp b/libstagefrighthw/stagefright_overlay_output.cpp
new file mode 100644
index 0000000..ac5fbdb
--- /dev/null
+++ b/libstagefrighthw/stagefright_overlay_output.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2010 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 "SecHardwareRenderer.h"
+
+#include <media/stagefright/HardwareAPI.h>
+
+using android::sp;
+using android::ISurface;
+using android::VideoRenderer;
+
+VideoRenderer *createRenderer(
+        const sp<ISurface> &surface,
+        const char *componentName,
+        OMX_COLOR_FORMATTYPE colorFormat,
+        size_t displayWidth, size_t displayHeight,
+        size_t decodedWidth, size_t decodedHeight) {
+    using android::SecHardwareRenderer;
+
+    SecHardwareRenderer *renderer =
+        new SecHardwareRenderer(
+                surface, displayWidth, displayHeight,
+                decodedWidth, decodedHeight,
+                colorFormat);
+
+    if (renderer->initCheck() != android::OK) {
+        delete renderer;
+        renderer = NULL;
+    }
+
+    return renderer;
+}
+