Merge change 22773 into eclair

* changes:
  Keep up with latest changes to overlay handling on that unnamable platform.

include/media/stagefright/OMXCodec.h

@@ -83,6 +83,7 @@ private:
         kRequiresLoadedToIdleAfterAllocation = 4,
         kRequiresAllocateBufferOnInputPorts  = 8,
         kRequiresFlushCompleteEmulation      = 16,
+        kRequiresAllocateBufferOnOutputPorts = 32,
     };
 
     struct BufferInfo {

include/media/stagefright/TIHardwareRenderer.h

@@ -46,6 +46,7 @@ private:
     size_t mFrameSize;
     sp<Overlay> mOverlay;
     Vector<void *> mOverlayAddresses;
+    bool mIsFirstFrame;
     size_t mIndex;
 
     TIHardwareRenderer(const TIHardwareRenderer &);

media/libstagefright/OMXCodec.cpp

@@ -735,6 +735,10 @@ status_t OMXCodec::allocateBuffersOnPort(OMX_U32 portIndex) {
                 && (mQuirks & kRequiresAllocateBufferOnInputPorts)) {
             err = mOMX->allocate_buffer_with_backup(
                     mNode, portIndex, mem, &buffer);
+        } else if (portIndex == kPortIndexOutput
+                && (mQuirks & kRequiresAllocateBufferOnOutputPorts)) {
+            err = mOMX->allocate_buffer(
+                    mNode, portIndex, def.nBufferSize, &buffer);
         } else {
             err = mOMX->use_buffer(mNode, portIndex, mem, &buffer);
         }

media/libstagefright/omx/Android.mk

@@ -6,6 +6,8 @@ include external/opencore/Config.mk
 LOCAL_C_INCLUDES := $(PV_INCLUDES)
 LOCAL_CFLAGS := $(PV_CFLAGS_MINUS_VISIBILITY)
 
+LOCAL_C_INCLUDES += $(TOP)/hardware/ti/omap3/liboverlay
+
 LOCAL_SRC_FILES:=                 \
 	OMX.cpp                   \
         QComHardwareRenderer.cpp  \

media/libstagefright/omx/TIHardwareRenderer.cpp

@@ -17,13 +17,15 @@
 #define LOG_TAG "TIHardwareRenderer"
 #include <utils/Log.h>
 
-#undef NDEBUG
-#include <assert.h>
-
 #include <media/stagefright/TIHardwareRenderer.h>
+#include <media/stagefright/MediaDebug.h>
 #include <ui/ISurface.h>
 #include <ui/Overlay.h>
 
+#include "v4l2_utils.h"
+
+#define CACHEABLE_BUFFERS 0x1
+
 namespace android {
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -37,10 +39,12 @@ TIHardwareRenderer::TIHardwareRenderer(
       mDisplayHeight(displayHeight),
       mDecodedWidth(decodedWidth),
       mDecodedHeight(decodedHeight),
-      mFrameSize((mDecodedWidth * mDecodedHeight * 3) / 2) {
+      mFrameSize(mDecodedWidth * mDecodedHeight * 2),
-    assert(mISurface.get() != NULL);
+      mIsFirstFrame(true),
-    assert(mDecodedWidth > 0);
+      mIndex(0) {
-    assert(mDecodedHeight > 0);
+    CHECK(mISurface.get() != NULL);
+    CHECK(mDecodedWidth > 0);
+    CHECK(mDecodedHeight > 0);
 
     sp<OverlayRef> ref = mISurface->createOverlay(
             mDisplayWidth, mDisplayHeight, OVERLAY_FORMAT_CbYCrY_422_I);
@@ -51,11 +55,14 @@ TIHardwareRenderer::TIHardwareRenderer(
     }
 
     mOverlay = new Overlay(ref);
+    mOverlay->setParameter(CACHEABLE_BUFFERS, 0);
 
-    for (size_t i = 0; i < mOverlay->getBufferCount(); ++i) {
+    for (size_t i = 0; i < (size_t)mOverlay->getBufferCount(); ++i) {
-        mOverlayAddresses.push(mOverlay->getBufferAddress((void *)i));
+        mapping_data_t *data =
+            (mapping_data_t *)mOverlay->getBufferAddress((void *)i);
+
+        mOverlayAddresses.push(data->ptr);
     }
-    mIndex = mOverlayAddresses.size() - 1;
 }
 
 TIHardwareRenderer::~TIHardwareRenderer() {
@@ -70,27 +77,51 @@ TIHardwareRenderer::~TIHardwareRenderer() {
 
 void TIHardwareRenderer::render(
         const void *data, size_t size, void *platformPrivate) {
-    // assert(size == mFrameSize);
+    // CHECK_EQ(size, mFrameSize);
 
     if (mOverlay.get() == NULL) {
         return;
     }
 
 #if 0
-    overlay_buffer_t buffer;
+    size_t i = 0;
-    if (mOverlay->dequeueBuffer(&buffer) == OK) {
+    for (; i < mOverlayAddresses.size(); ++i) {
-        void *addr = mOverlay->getBufferAddress(buffer);
+        if (mOverlayAddresses[i] == data) {
+            break;
+        }
 
-        memcpy(addr, data, size);
+        if (mIsFirstFrame) {
+            LOGI("overlay buffer #%d: %p", i, mOverlayAddresses[i]);
+        }
+    }
 
-        mOverlay->queueBuffer(buffer);
+    if (i == mOverlayAddresses.size()) {
+        LOGE("No suitable overlay buffer found.");
+        return;
+    }
+
+    mOverlay->queueBuffer((void *)i);
+
+    overlay_buffer_t overlay_buffer;
+    if (!mIsFirstFrame) {
+        CHECK_EQ(mOverlay->dequeueBuffer(&overlay_buffer), OK);
+    } else {
+        mIsFirstFrame = false;
     }
 #else
     memcpy(mOverlayAddresses[mIndex], data, size);
+
     mOverlay->queueBuffer((void *)mIndex);
 
-    if (mIndex-- == 0) {
+    if (++mIndex == mOverlayAddresses.size()) {
-        mIndex = mOverlayAddresses.size() - 1;
+        mIndex = 0;
+    }
+
+    overlay_buffer_t overlay_buffer;
+    if (!mIsFirstFrame) {
+        CHECK_EQ(mOverlay->dequeueBuffer(&overlay_buffer), OK);
+    } else {
+        mIsFirstFrame = false;
     }
 #endif
 }